javonet-nodejs-sdk 2.5.17 → 2.5.18

package/dist/utils/UtilsConst.cjs

@@ -0,0 +1,101 @@
+"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 UtilsConst_exports = {};
+__export(UtilsConst_exports, {
+  UtilsConst: () => UtilsConst
+});
+module.exports = __toCommonJS(UtilsConst_exports);
+var import_Runtime = require("./Runtime.cjs");
+const import_meta = {};
+let fs = null;
+let path = null;
+const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
+class UtilsConst {
+  /** @type {string} */
+  static _javonetWorkingDirectory = ".";
+  /** @type {string} */
+  static _configSource = "";
+  /** @type {string} */
+  static _licenseKey = "";
+  /**
+   * @param {string} inputPath
+   */
+  static setJavonetWorkingDirectory(inputPath) {
+    if (!inputPath) {
+      return;
+    }
+    let normalizedPath = inputPath.replace(/\\/g, "/");
+    if (!normalizedPath.endsWith("/")) {
+      normalizedPath += "/";
+    }
+    if ((0, import_Runtime.isNodejsRuntime)()) {
+      if (!fs) {
+        fs = requireDynamic("fs");
+      }
+      if (!fs.existsSync(normalizedPath)) {
+        fs.mkdirSync(normalizedPath, { recursive: true });
+        fs.chmodSync(normalizedPath, 448);
+      }
+    }
+    UtilsConst._javonetWorkingDirectory = normalizedPath;
+  }
+  /**
+   * @returns {string}
+   */
+  static getJavonetWorkingDirectory() {
+    if ((0, import_Runtime.isNodejsRuntime)() && !UtilsConst._javonetWorkingDirectory) {
+      if (!path) {
+        path = requireDynamic("path");
+      }
+      UtilsConst._javonetWorkingDirectory = path.resolve() + "/";
+    }
+    return UtilsConst._javonetWorkingDirectory;
+  }
+  /**
+   * @param {string} value
+   */
+  static setConfigSource(value) {
+    UtilsConst._configSource = value;
+  }
+  /**
+   * @returns {string}
+   */
+  static getConfigSource() {
+    return UtilsConst._configSource;
+  }
+  /**
+   * @param {string} value
+   */
+  static setLicenseKey(value) {
+    if (!value || value === "your-license-key") {
+      return;
+    }
+    UtilsConst._licenseKey = value;
+  }
+  /**
+   * @returns {string}
+   */
+  static getLicenseKey() {
+    return UtilsConst._licenseKey;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UtilsConst
+});

package/dist/utils/connectionData/IConnectionData.cjs

@@ -22,12 +22,21 @@ __export(IConnectionData_exports, {
 });
 module.exports = __toCommonJS(IConnectionData_exports);
 class IConnectionData {
+  /**
+   * @returns {ConnectionType}
+   */
   get connectionType() {
     throw new Error("You have to implement the method connectionType!");
   }
+  /**
+   * @returns {string}
+   */
   get hostname() {
     throw new Error("You have to implement the method hostname!");
   }
+  /**
+   * @returns {number[]}
+   */
   serializeConnectionData() {
     throw new Error("You have to implement the method serializeConnectionData!");
   }

package/dist/utils/connectionData/InMemoryConnectionData.cjs

@@ -29,12 +29,22 @@ class InMemoryConnectionData extends import_IConnectionData.IConnectionData {
     this._connectionType = import_ConnectionType.ConnectionType.IN_MEMORY;
     this._hostname = "";
   }
+  /**
+   * @returns {ConnectionType}
+   */
   get connectionType() {
     return this._connectionType;
   }
+  /**
+   * @returns {string}
+   */
   get hostname() {
     return this._hostname;
   }
+  /**
+   * Serializes the connection data.
+   * @returns {number[]} An array of connection data values.
+   */
   serializeConnectionData() {
     return [this.connectionType, 0, 0, 0, 0, 0, 0];
   }

package/dist/utils/connectionData/WsConnectionData.cjs

@@ -51,6 +51,10 @@ class WsConnectionData extends import_IConnectionData.IConnectionData {
   serializeConnectionData() {
     return [this.connectionType, 0, 0, 0, 0, 0, 0];
   }
+  /**
+   * @param {WsConnectionData} other
+   * @returns {boolean}
+   */
   equals(other) {
     return other instanceof WsConnectionData && this._hostname === other.hostname;
   }

package/dist/utils/nodejs/connectionData/TcpConnectionData.cjs

@@ -27,6 +27,18 @@ var import_Runtime = require("../../Runtime.cjs");
 const import_meta = {};
 const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 class TcpConnectionData extends import_IConnectionData.IConnectionData {
+  /** @type {string} */
+  ipAddress = "";
+  /** @type {number} */
+  _port = 0;
+  /** @type {string} */
+  _hostname = "";
+  /** @type {ConnectionType} */
+  _connectionType = import_ConnectionType.ConnectionType.TCP;
+  /**
+   * @param {string} hostname
+   * @param {number} port
+   */
   constructor(hostname, port) {
     super();
     this._port = port;
@@ -38,6 +50,9 @@ class TcpConnectionData extends import_IConnectionData.IConnectionData {
       this.ipAddress = this.resolveIpAddress(hostname);
     }
   }
+  /**
+   * @returns {ConnectionType}
+   */
   get connectionType() {
     return this._connectionType;
   }
@@ -56,7 +71,7 @@ class TcpConnectionData extends import_IConnectionData.IConnectionData {
   }
   /**
    * @param {string} hostname
-   * @returns {string|null}
+   * @returns {string}
    */
   resolveIpAddress(hostname) {
     try {
@@ -69,28 +84,43 @@ class TcpConnectionData extends import_IConnectionData.IConnectionData {
           return dns.resolve4(hostname, (err, addresses) => {
             if (err) {
               console.error(err);
-              return null;
+              return "";
             }
             return addresses[0];
           });
         }
       }
+      return "";
     } catch (error) {
-      if (error.code === "MODULE_NOT_FOUND") {
+      const err = (
+        /** @type {{code?: string}} */
+        error
+      );
+      if (err.code === "MODULE_NOT_FOUND") {
         throw new Error("dns module not found. Please install it using npm install dns");
       }
       throw error;
     }
   }
+  /**
+   * Serializes the connection data.
+   * @returns {number[]} An array of connection data values.
+   */
   serializeConnectionData() {
     let result = [this.connectionType];
     result = result.concat(this.#getAddressBytes());
     result = result.concat(this.#getPortBytes());
     return result;
   }
+  /**
+   * @returns {number[]} An array of address bytes.
+   */
   #getAddressBytes() {
     return this.ipAddress.split(".").map(Number);
   }
+  /**
+   * @returns {number[]} An array of port bytes.
+   */
   #getPortBytes() {
     return [this._port & 255, this._port >> 8];
   }

package/lib/core/delegatesCache/DelegatesCache.js

@@ -1,3 +1,4 @@
+// @ts-check
 import { generateGUID } from '../../utils/guid/generateGuid.js'
 
 /**

package/lib/core/handler/AbstractHandler.js

@@ -1,36 +1,54 @@
+// @ts-check
 import { Command } from '../../utils/Command.js'
 
 class AbstractHandler {
+    /**
+     * @type {Record<number, AbstractHandler>}
+     */
     handlers = []
 
     constructor() {
         if (new.target === AbstractHandler) throw new TypeError('You cannot instantiate abstract class')
     }
 
-    // eslint-disable-next-line no-unused-vars
+    /**
+     * @param {Command} command
+     */
     process(command) {
         throw new Error('process must be implemented')
     }
 
+    /**
+     * @param {Command} command
+     */
     handleCommand(command) {
         this.iterate(command)
         return this.process(command)
     }
 
-    iterate(cmd) {
-        for (let i = 0; i < cmd.payload.length; i++) {
-            if (cmd.payload[i] instanceof Command) {
-                let inner = cmd.payload[i]
-                cmd.payload[i] = this.handlers[inner.commandType].handleCommand(inner)
+    /**
+     * @param {Command} command
+     */
+    iterate(command) {
+        for (let i = 0; i < command.payload.length; i++) {
+            if (command.payload[i] instanceof Command) {
+                let inner = command.payload[i]
+                command.payload[i] = this.handlers[inner.commandType].handleCommand(inner)
             }
         }
     }
 
+    /**
+     * 
+     * @param {*} error 
+     * @param {*} class_name 
+     * @returns 
+     */
     process_stack_trace(error, class_name) {
-        let stackTraceArray = error.stack.split('\n').map((frame) => frame.trim())
-        stackTraceArray.forEach((str, index) => {
+        let stackTraceArray = error.stack.split('\n').map((/** @type {string} */ frame) => frame.trim())
+        stackTraceArray.forEach((/** @type {string} */ str, /** @type {number} */ index) => {
             if (str.includes(class_name)) {
-                stackTraceArray = stackTraceArray.slice(0, index).filter((s) => !s.includes(class_name))
+                stackTraceArray = stackTraceArray.slice(0, index).filter((/** @type {string} */ s) => !s.includes(class_name))
             }
         })
         error.stack = stackTraceArray.join(' \n ')

package/lib/core/handler/ArrayGetItemHandler.js

@@ -1,5 +1,10 @@
+// @ts-check
 import { AbstractHandler } from './AbstractHandler.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
 class ArrayGetItemHandler extends AbstractHandler {
     requiredParametersCount = 2
 
@@ -7,6 +12,9 @@ class ArrayGetItemHandler extends AbstractHandler {
         super()
     }
 
+    /**
+     * @param {Command} command
+     */
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {
@@ -21,7 +29,7 @@ class ArrayGetItemHandler extends AbstractHandler {
             }
 
             if (indexes.length === 1) {
-                return array[indexes]
+                return array[indexes[0]]
             } else {
                 let array_copy = [...array]
                 for (let i = 0; i < indexes.length; i++) {

package/lib/core/handler/ArrayGetRankHandler.js

@@ -1,11 +1,20 @@
+// @ts-check
 import { AbstractHandler } from './AbstractHandler.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
 class ArrayGetRankHandler extends AbstractHandler {
     requiredParametersCount = 1
 
     constructor() {
         super()
     }
+
+    /**
+     * @param {Command} command
+     */
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {

package/lib/core/handler/ArrayGetSizeHandler.js

@@ -1,5 +1,10 @@
+// @ts-check
 import { AbstractHandler } from './AbstractHandler.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
 class ArrayGetSizeHandler extends AbstractHandler {
     requiredParametersCount = 1
 
@@ -7,6 +12,9 @@ class ArrayGetSizeHandler extends AbstractHandler {
         super()
     }
 
+    /**
+     * @param {Command} command
+     */
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {

package/lib/core/handler/ArrayHandler.js

@@ -1,10 +1,18 @@
+// @ts-check
 import { AbstractHandler } from './AbstractHandler.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
 class ArrayHandler extends AbstractHandler {
     constructor() {
         super()
     }
 
+    /**
+     * @param {Command} command
+     */
     process(command) {
         try {
             let processedArray = command.payload

package/lib/core/handler/ArraySetItemHandler.js

@@ -1,5 +1,10 @@
+// @ts-check
 import { AbstractHandler } from './AbstractHandler.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
 class ArraySetItemHandler extends AbstractHandler {
     requiredParametersCount = 3
 
@@ -7,6 +12,9 @@ class ArraySetItemHandler extends AbstractHandler {
         super()
     }
 
+    /**
+     * @param {Command} command
+     */
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {
@@ -15,6 +23,8 @@ class ArraySetItemHandler extends AbstractHandler {
 
             let array = command.payload[0]
             let value = command.payload[2]
+
+            /** @type {number[]} */
             let indexes
             if (Array.isArray(command.payload[1])) {
                 indexes = command.payload[1]
@@ -24,7 +34,7 @@ class ArraySetItemHandler extends AbstractHandler {
 
             if (indexes.length === 1) {
                 // one-dimensional array
-                array[indexes] = value
+                array[indexes[0]] = value
             } else {
                 // multi-dimensional array
                 for (let i = 0; i < indexes.length - 1; i++) {

package/lib/core/handler/CastingHandler.js

@@ -1,7 +1,14 @@
+// @ts-check
 import { AbstractHandler } from './AbstractHandler.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
 class CastingHandler extends AbstractHandler {
-    // eslint-disable-next-line no-unused-vars
+    /**
+     * @param {Command} command
+     */
     process(command) {
         throw new Error(`Dynamically typed languages are not supporting casting`)
     }

package/lib/core/handler/ConvertTypeHandler.js

@@ -1,6 +1,11 @@
-import { TypesConverter } from '../../utils/nodejs/TypesConverter.js'
+// @ts-check
+import { TypesHandler } from '../../utils/TypesHandler.js'
 import { AbstractHandler } from './AbstractHandler.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
 /**
  * ConvertTypeHandler class handles the conversion of JType to Type.
  */
@@ -16,17 +21,17 @@ class ConvertTypeHandler extends AbstractHandler {
 
     /**
      * 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) {
         this.validateCommand(command)
-        return TypesConverter.convertJTypeToType(command.payload[0])
+        return TypesHandler.convertTypeToJType(command.payload[0])
     }
 
     /**
      * 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) {
         if (command.payload.length < this.requiredParametersCount) {

package/lib/core/handler/CreateClassInstanceHandler.js

@@ -1,5 +1,10 @@
+// @ts-check
 import { AbstractHandler } from './AbstractHandler.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
 class CreateClassInstanceHandler extends AbstractHandler {
     requiredParametersCount = 1
 
@@ -7,6 +12,9 @@ class CreateClassInstanceHandler extends AbstractHandler {
         super()
     }
 
+    /**
+     * @param {Command} command
+     */
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {
@@ -16,10 +24,8 @@ class CreateClassInstanceHandler extends AbstractHandler {
             let constructorArguments = command.payload.slice(1)
             let instance = new clazz(...constructorArguments)
             if (typeof instance === 'undefined') {
-                // eslint-disable-next-line no-undef
-                let methods = Object.getOwnPropertyNames(type).filter(function (property) {
-                    // eslint-disable-next-line no-undef
-                    return typeof type[property] === 'function'
+                let methods = Object.getOwnPropertyNames(clazz).filter(function (property) {
+                    return typeof clazz[property] === 'function'
                 })
                 let message = `Method 'constructor' not found in class. Available methods:\n`
                 methods.forEach((methodIter) => {

package/lib/core/handler/DestructReferenceHandler.js

@@ -1,11 +1,19 @@
+// @ts-check
 import { ReferencesCache } from '../referenceCache/ReferencesCache.js'
 import { AbstractHandler } from './AbstractHandler.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
 class DestructReferenceHandler extends AbstractHandler {
     constructor() {
         super()
     }
 
+    /**
+     * @param {Command} command
+     */
     process(command) {
         try {
             let cache = ReferencesCache.getInstance()

package/lib/core/handler/EnableNamespaceHandler.js

@@ -1,12 +1,20 @@
+// @ts-check
 import { NamespaceCache } from '../namespaceCache/NamespaceCache.js'
 import { AbstractHandler } from './AbstractHandler.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
 class EnableNamespaceHandler extends AbstractHandler {
     constructor() {
         super()
         this.requiredParametersCount = 1
     }
 
+    /**
+     * @param {Command} command
+     */
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {

package/lib/core/handler/EnableTypeHandler.js

@@ -1,6 +1,11 @@
+// @ts-check
 import { TypeCache } from '../typeCache/TypeCache.js'
 import { AbstractHandler } from './AbstractHandler.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
 class EnableTypeHandler extends AbstractHandler {
     requiredParametersCount = 1
 
@@ -8,6 +13,9 @@ class EnableTypeHandler extends AbstractHandler {
         super()
     }
 
+    /**
+     * @param {Command} command
+     */
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {

package/lib/core/handler/GetGlobalStaticFieldHandler.js

@@ -1,5 +1,10 @@
+// @ts-check
 import { AbstractHandler } from './AbstractHandler.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
 class GetGlobalStaticFieldHandler extends AbstractHandler {
     requiredParametersCount = 1
 
@@ -7,6 +12,9 @@ class GetGlobalStaticFieldHandler extends AbstractHandler {
         super()
     }
 
+    /**
+     * @param {Command} command
+     */
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {
@@ -17,6 +25,7 @@ class GetGlobalStaticFieldHandler extends AbstractHandler {
             let fieldToGet
 
             for (let i = 0; i < splitted.length; i++) {
+                // @ts-expect-error
                 fieldToGet = !fieldToGet ? global[splitted[i]] : fieldToGet[splitted[i]]
                 if (typeof fieldToGet === 'undefined') {
                     let fields = Object.keys(global)

package/lib/core/handler/GetInstanceFieldHandler.js

@@ -1,5 +1,10 @@
+// @ts-check
 import { AbstractHandler } from './AbstractHandler.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
 class GetInstanceFieldHandler extends AbstractHandler {
     requiredParametersCount = 2
 
@@ -7,6 +12,9 @@ class GetInstanceFieldHandler extends AbstractHandler {
         super()
     }
 
+    /**
+     * @param {Command} command
+     */
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {

package/lib/core/handler/GetInstanceMethodAsDelegateHandler.js

@@ -1,3 +1,4 @@
+// @ts-check
 import { AbstractHandler } from './AbstractHandler.js'
 
 /**
@@ -32,6 +33,10 @@ class GetInstanceMethodAsDelegateHandler extends AbstractHandler {
         const methodName = command.payload[1]
         this.args = command.payload.length > 2 ? command.payload.slice(2) : []
 
+        if (!this.instance) {
+            throw new Error('Instance is null or undefined')
+        }
+
         // Find the method on the instance
         this.method = this.getMethod(this.instance, methodName)
         if (!this.method) {
@@ -50,7 +55,7 @@ class GetInstanceMethodAsDelegateHandler extends AbstractHandler {
      * @returns {Function|null} The found method or null if not found.
      */
     getMethod(type, methodName) {
-        const method = type[methodName]
+        const method = /** @type {any} */ (type)[methodName]
         return typeof method === 'function' ? method : null
     }
 
@@ -61,11 +66,11 @@ class GetInstanceMethodAsDelegateHandler extends AbstractHandler {
      * @returns {Error} The error with detailed message.
      */
     createMethodNotFoundError(type, methodName) {
-        const methods = Object.getOwnPropertyNames(type.prototype).filter(
-            (key) => typeof type.prototype[key] === 'function'
+        const methods = Object.getOwnPropertyNames(/** @type {{prototype: Object}} */ (type).prototype).filter(
+            (key) => typeof /** @type {any} */ (type).prototype[key] === 'function'
         )
         const availableMethods = methods.map((name) => `${name}()`)
-        const message = `Method ${methodName} not found in class ${type.name}. Available instance public methods:\n${availableMethods.join('\n')}`
+        const message = `Method ${methodName} not found in class ${/** @type {{name: string}} */ (type).name}. Available instance public methods:\n${availableMethods.join('\n')}`
         return new Error(message)
     }
 }