javonet-nodejs-sdk 2.5.16 → 2.5.18

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)
     }
 }

package/lib/core/handler/GetStaticFieldHandler.js

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

package/lib/core/handler/GetStaticMethodAsDelegateHandler.js

@@ -1,6 +1,10 @@
-// eslint-disable-next-line no-unused-vars
+// @ts-check
 import { AbstractHandler } from './AbstractHandler.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
 /**
  * Handles retrieving a static method as a delegate.
  */
@@ -19,7 +23,6 @@ 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.
      */
@@ -47,12 +50,10 @@ 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, methodName) {
-        const method = type[methodName]
+        const method = /** @type {any} */ (type)[methodName]
         return typeof method === 'function' ? method : null
     }
 
@@ -63,9 +64,9 @@ class GetStaticMethodAsDelegateHandler extends AbstractHandler {
      * @returns {Error} The error with detailed message.
      */
     createMethodNotFoundError(type, methodName) {
-        const methods = Object.keys(type).filter((key) => typeof type[key] === 'function')
+        const methods = Object.keys(type).filter((key) => typeof /** @type {any} */ (type)[key] === 'function')
         const availableMethods = methods.map((name) => `${name}()`)
-        const message = `Method ${methodName} not found in class ${type.name}. Available public static methods:\n${availableMethods.join('\n')}`
+        const message = `Method ${methodName} not found in class ${/** @type {{name: string}} */ (type).name}. Available public static methods:\n${availableMethods.join('\n')}`
         return new Error(message)
     }
 }

package/lib/core/handler/GetTypeHandler.js

@@ -1,22 +1,31 @@
+// @ts-check
 import { AbstractHandler } from './AbstractHandler.js'
 import { LoadLibraryHandler } from './LoadLibraryHandler.js'
 import { NamespaceCache } from '../namespaceCache/NamespaceCache.js'
 import { TypeCache } from '../typeCache/TypeCache.js'
 import { getRequire } from '../../utils/Runtime.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 class GetTypeHandler extends AbstractHandler {
     constructor() {
         super()
         /** @type {number} */
         this.requiredParametersCount = 1
-        /** @type {NamespaceCache | null} */
+        /** @type {NamespaceCache} */
         this.namespaceCache = new NamespaceCache()
-        /** @type {TypeCache | null} */
+        /** @type {TypeCache} */
         this.typeCache = new TypeCache()
-        /** @type {LoadLibraryHandler | null} */
+        /** @type {LoadLibraryHandler} */
         this.loadLibaryHandler = new LoadLibraryHandler()
     }
 
+    /**
+     * 
+     * @param {Command} command 
+     * @returns 
+     */
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {
@@ -25,7 +34,7 @@ class GetTypeHandler extends AbstractHandler {
             const { payload } = command
             let typeName = payload[0]
             typeName = typeName.replace('.js', '')
-            let typeToReturn = global[typeName]
+            const typeToReturn = /** @type {any} */ (global)[typeName]
             if (typeToReturn === undefined) {
                 let message = `Type ${typeName} not found\n`
                 message += 'Available types:\n'
@@ -54,7 +63,8 @@ class GetTypeHandler extends AbstractHandler {
     }
 
     getAvailableTypes() {
-        let availableTypes = []
+        /** @type {string[]} */
+        const availableTypes = []
         this.loadLibaryHandler.getLoadedLibraries().forEach((lib) => {
             const dynamicRequire = getRequire(import.meta.url)
 

package/lib/core/handler/Handler.js

@@ -1,3 +1,4 @@
+//@ts-check
 import { ReferencesCache } from '../referenceCache/ReferencesCache.js'
 import { ValueHandler } from './ValueHandler.js'
 import { LoadLibraryHandler } from './LoadLibraryHandler.js'
@@ -26,26 +27,14 @@ import { InvokeDelegateHandler } from './InvokeDelegateHandler.js'
 import { InvokeGlobalFunctionHandler } from './InvokeGlobalFunctionHandler.js'
 import { CommandType } from '../../utils/CommandType.js'
 import { Command } from '../../utils/Command.js'
+import { TypesHandler } from '../../utils/TypesHandler.js'
 import { ExceptionSerializer } from '../../utils/exception/ExceptionSerializer.js'
 import { ConvertTypeHandler } from './ConvertTypeHandler.js'
 import { AbstractHandler } from './AbstractHandler.js'
 
 /**
- * @param {any} response
- * @returns {boolean}
+ * @typedef {import('../../types.d.ts').RuntimeName} RuntimeName
  */
-function isResponseSimpleType(response) {
-    let type = typeof response
-    return ['string', 'boolean', 'number'].includes(type)
-}
-
-/**
- * @param {any} response
- * @returns {boolean}
- */
-function isResponseNull(response) {
-    return response === null
-}
 
 /**
  * @type {Record<number, AbstractHandler>}
@@ -86,16 +75,22 @@ class Handler {
     constructor(interpreter) {
         this.interpreter = interpreter
 
+        if (!this.interpreter) {
+            throw new Error('interpreter is undefined in Handler constructor')
+        }
+
         // dynamically create pass delegate handler with interpreter
-        handlers[CommandType.PassDelegate] = new PassDelegateHandler(interpreter)
+        // @ts-expect-error
+        handlers[CommandType.PassDelegate] = new PassDelegateHandler(this.interpreter)
 
         Object.keys(handlers).forEach((commandTypeHandler) => {
+            // @ts-expect-error
             handlers[commandTypeHandler].handlers = handlers
         })
     }
 
     /**
-     * @param {{ commandType: number; payload: any[]; runtimeName: number; }} command
+     * @param {Command} command
      */
     handleCommand(command) {
         try {
@@ -112,11 +107,11 @@ class Handler {
 
     /**
      * @param {any} response
-     * @param {number} runtimeName
+     * @param {RuntimeName} runtimeName
      * @returns {Command}
      */
     parseCommand(response, runtimeName) {
-        if (isResponseNull(response) || isResponseSimpleType(response)) {
+        if (TypesHandler.isPrimitiveOrNullOrUndefined(response)) {
             return Command.createResponse(response, runtimeName)
         } else {
             let cache = ReferencesCache.getInstance()

package/lib/core/handler/InvokeDelegateHandler.js

@@ -1,6 +1,11 @@
+// @ts-check
 import { delegatesCacheInstance } from '../delegatesCache/DelegatesCache.js'
 import { AbstractHandler } from './AbstractHandler.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
 /**
  * Handles invoking a delegate by GUID.
  */

package/lib/core/handler/InvokeGlobalFunctionHandler.js

@@ -1,5 +1,10 @@
+// @ts-check
 import { AbstractHandler } from './AbstractHandler.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
 class InvokeGlobalFunctionHandler extends AbstractHandler {
     requiredParametersCount = 1
 
@@ -7,6 +12,9 @@ class InvokeGlobalFunctionHandler extends AbstractHandler {
         super()
     }
 
+    /**
+     * @param {Command} command
+     */
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {
@@ -15,11 +23,13 @@ class InvokeGlobalFunctionHandler extends AbstractHandler {
             const { payload } = command
             const functionName = payload[0]
             const args = payload.slice(1)
-
+            // @ts-expect-error
             if (typeof global[functionName] === 'function') {
+                // @ts-expect-error
                 return Reflect.apply(global[functionName], undefined, args)
             } else {
                 let methods = Object.getOwnPropertyNames(global).filter(function (property) {
+                    // @ts-expect-error
                     return typeof global[property] === 'function'
                 })
                 let message = `Method ${functionName} not found in global. Available methods:\n`

package/lib/core/handler/InvokeInstanceMethodHandler.js

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

package/lib/core/handler/InvokeStaticMethodHandler.js

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

package/lib/core/handler/LoadLibraryHandler.js

@@ -1,15 +1,24 @@
+// @ts-check
 import { getRequire } from '../../utils/Runtime.js'
 import { AbstractHandler } from './AbstractHandler.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
 const dynamicImport = getRequire(import.meta.url)
 class LoadLibraryHandler extends AbstractHandler {
     requiredParametersCount = 1
+    /** @type {string[]} */
     static loadedLibraries = []
 
     constructor() {
         super()
     }
 
+    /**
+     * @param {Command} command
+     */
     process(command) {
         if (command.payload.length < this.requiredParametersCount) {
             throw new Error('Load Library parameters mismatch')
@@ -34,10 +43,12 @@ class LoadLibraryHandler extends AbstractHandler {
                 throw this.process_stack_trace(error, this.constructor.name)
             }
         }
+        // @ts-expect-error
         global[libraryName] = moduleExports
 
         for (const [key, value] of Object.entries(moduleExports)) {
             // Here, `key` is the name of the export, and `value` is the exported type itself.
+            // @ts-expect-error
             global[key] = value
         }
         return 0

package/lib/core/handler/SetGlobalStaticFieldHandler.js

@@ -1,5 +1,10 @@
+// @ts-check
 import { AbstractHandler } from './AbstractHandler.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
 class SetGlobalStaticFieldHandler extends AbstractHandler {
     requiredParametersCount = 2
 
@@ -7,6 +12,9 @@ class SetGlobalStaticFieldHandler extends AbstractHandler {
         super()
     }
 
+    /**
+     * @param {Command} command
+     */
     process(command) {
         try {
             if (command.payload.length < this.requiredParametersCount) {
@@ -18,6 +26,7 @@ class SetGlobalStaticFieldHandler extends AbstractHandler {
             let fieldToSet
 
             for (let i = 0; i < splitted.length; i++) {
+                // @ts-expect-error
                 if (typeof (fieldToSet ? fieldToSet[splitted[i]] : global[splitted[i]]) === 'undefined') {
                     let fields = Object.keys(fieldToSet ? fieldToSet : global)
                     let message = `Field ${splitted[i]} not found in object. Available fields:\n`
@@ -26,6 +35,7 @@ class SetGlobalStaticFieldHandler extends AbstractHandler {
                     })
                     throw new Error(message)
                 }
+                // @ts-expect-error
                 fieldToSet = !fieldToSet ? global[splitted[i]] : fieldToSet[splitted[i]]
             }
             fieldToSet = value

package/lib/core/handler/SetInstanceFieldHandler.js

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

package/lib/core/handler/SetStaticFieldHandler.js

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

package/lib/core/handler/ValueHandler.js

@@ -1,9 +1,18 @@
+// @ts-check
 import { AbstractHandler } from './AbstractHandler.js'
 
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
 class ValueHandler extends AbstractHandler {
     constructor() {
         super()
     }
+
+    /**
+     * @param {Command} command
+     * @returns {unknown}
+     */
     process(command) {
         const { payload } = command
         return payload[0]