javonet-nodejs-sdk 2.5.17 → 2.5.18

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]

package/lib/core/interpreter/Interpreter.js

@@ -1,5 +1,6 @@
+// @ts-check
 import { ConnectionType } from '../../utils/ConnectionType.js'
-import { isNodejsRuntime, getRuntimeExtension, getRequire, getDirname } from '../../utils/Runtime.js'
+import { isNodejsRuntime, getRequire } from '../../utils/Runtime.js'
 import { RuntimeName } from '../../utils/RuntimeName.js'
 import { CommandDeserializer } from '../protocol/CommandDeserializer.js'
 import { CommandSerializer } from '../protocol/CommandSerializer.js'
@@ -8,17 +9,16 @@ import { TransmitterWebsocket } from '../transmitter/TransmitterWebsocket.js'
 import { Handler } from '../handler/Handler.js'
 
 /**
- * @typedef {import('../receiver/Receiver.js').Receiver} Receiver
- * @typedef {import('../transmitter/Transmitter.js').Transmitter} Transmitter
- * @typedef {import('../transmitter/TransmitterWebsocket.js').TransmitterWebsocket} TransmitterWebsocket
- * @typedef {import('../transmitter/TransmitterWebsocketBrowser.js').TransmitterWebsocketBrowser} TransmitterWebsocketBrowser
+ * @typedef {import('../../utils/connectionData/IConnectionData.js').IConnectionData} IConnectionData
+ * @typedef {typeof import('../../types.d.ts').RuntimeName} RuntimeNameType
+ * @typedef {import('../../utils/Command.js').Command} Command
  */
 
-/** @type {Receiver | null} */
+/** @type {typeof import('../receiver/Receiver.js').Receiver | null} */
 let _Receiver = null
-/** @type {Transmitter | null} */
+/** @type {typeof import('../transmitter/Transmitter.js').Transmitter | null} */
 let _Transmitter = null
-/** @type {TransmitterWebsocket | null} */
+/** @type {typeof import('../transmitter/TransmitterWebsocket.js').TransmitterWebsocket | typeof import('../transmitter/TransmitterWebsocketBrowser.js').TransmitterWebsocketBrowser | null} */
 let _TransmitterWebsocket = null
 
 if (!_TransmitterWebsocket) {
@@ -28,7 +28,8 @@ if (!_TransmitterWebsocket) {
 const requireDynamic = getRequire(import.meta.url)
 
 export class Interpreter {
-    handler
+    /** @type {Handler | null} */
+    handler = null
     /**
      *
      * @param {Command} command
@@ -37,8 +38,12 @@ export class Interpreter {
      */
     async executeAsync(command, connectionData) {
         try {
+            if (!this.handler) {
+                this.handler = new Handler(this)
+            }
             let messageByteArray = new CommandSerializer().serialize(command, connectionData)
-            let responseByteArray
+            /** @type {Int8Array | undefined} */
+            let responseByteArray = undefined
 
             if (
                 command.runtimeName === RuntimeName.Nodejs &&
@@ -47,16 +52,16 @@ export class Interpreter {
                 if (isNodejsRuntime()) {
                     // lazy receiver loading
                     if (!_Receiver) {
-                        const { Receiver } = requireDynamic('../receiver/Receiver.js');
+                        const { Receiver } = requireDynamic('../receiver/Receiver.js')
                         _Receiver = Receiver
                     }
-                    responseByteArray = _Receiver.sendCommand(messageByteArray)
+                    responseByteArray = _Receiver?.sendCommand(messageByteArray)
                 } else {
                     throw new Error('Node.js runtime not found')
                 }
             } else if (connectionData.connectionType === ConnectionType.WEB_SOCKET) {
                 try {
-                    const _response = await _TransmitterWebsocket.sendCommand(
+                    const _response = await _TransmitterWebsocket?.sendCommand(
                         messageByteArray,
                         connectionData
                     )
@@ -76,13 +81,15 @@ export class Interpreter {
                         const { Transmitter } = requireDynamic('../transmitter/Transmitter.js')
                         _Transmitter = Transmitter
                     }
-                    responseByteArray = await _Transmitter.sendCommand(messageByteArray)
+                    responseByteArray = await _Transmitter?.sendCommand(messageByteArray)
                 } else {
                     throw new Error('Allowed only to run in nodejs runtime')
                 }
             }
+            if (!responseByteArray) {
+                throw new Error('No response received from Transmitter')
+            }
             return new CommandDeserializer(responseByteArray).deserialize()
-            // eslint-disable-next-line no-unused-vars
         } catch (error) {
             throw error
         }
@@ -91,13 +98,17 @@ export class Interpreter {
     /**
      *
      * @param {Command} command
-     * @param {WsConnectionData} connectionData
-     * @returns {Promise<Command>}
+     * @param {IConnectionData} connectionData
+     * @returns {Command | Promise<Command>}
      */
     execute(command, connectionData) {
         try {
+            if (!this.handler) {
+                this.handler = new Handler(this)
+            }
             let messageByteArray = new CommandSerializer().serialize(command, connectionData)
-            let responseByteArray
+            /** @type {Int8Array | undefined} */
+            let responseByteArray = undefined
 
             if (
                 command.runtimeName === RuntimeName.Nodejs &&
@@ -106,14 +117,18 @@ export class Interpreter {
                 if (isNodejsRuntime()) {
                     // lazy receiver loading
                     if (!_Receiver) {
-                        const { Receiver } = requireDynamic('../receiver/Receiver.js');
+                        const { Receiver } = requireDynamic('../receiver/Receiver.js')
                         _Receiver = Receiver
                     }
-                    responseByteArray = _Receiver.sendCommand(messageByteArray)
+                    responseByteArray = _Receiver?.sendCommand(messageByteArray)
                 }
             } else if (connectionData.connectionType === ConnectionType.WEB_SOCKET) {
                 // lazy transmitter websocket loading
-                const promise = _TransmitterWebsocket.sendCommand(messageByteArray, connectionData)
+                const promise = _TransmitterWebsocket?.sendCommand(messageByteArray, connectionData)
+
+                if (!promise) {
+                    throw new Error('TransmitterWebsocket not found')
+                }
 
                 return promise
                     .then((_response) => {
@@ -133,13 +148,16 @@ export class Interpreter {
                         const { Transmitter } = requireDynamic('../transmitter/Transmitter.js')
                         _Transmitter = Transmitter
                     }
-                    responseByteArray = _Transmitter.sendCommand(messageByteArray)
+
+                    responseByteArray = _Transmitter?.sendCommand(messageByteArray)
                 } else {
                     throw new Error('Allowed only to run in nodejs runtime')
                 }
             }
+            if (!responseByteArray) {
+                throw new Error('No response received from Transmitter')
+            }
             return new CommandDeserializer(responseByteArray).deserialize()
-            // eslint-disable-next-line no-unused-vars
         } catch (error) {
             throw error
         }
@@ -147,7 +165,7 @@ export class Interpreter {
 
     /**
      *
-     * @param {number[]} messageByteArray
+     * @param {Int8Array} messageByteArray
      * @returns {Command}
      */
     process(messageByteArray) {

package/lib/core/namespaceCache/NamespaceCache.js

@@ -1,5 +1,9 @@
+// @ts-check
+
 class NamespaceCache {
+    /** @type {NamespaceCache | null} */
     static _instance = null
+    /** @type {string[]} */
     namespaceCache = []
 
     constructor() {
@@ -9,14 +13,24 @@ class NamespaceCache {
         return NamespaceCache._instance
     }
 
+    /**
+     * @param {string} namespaceRegex
+     */
     cacheNamespace(namespaceRegex) {
         this.namespaceCache.push(namespaceRegex)
     }
 
+    /**
+     * @returns {boolean}
+     */
     isNamespaceCacheEmpty() {
         return this.namespaceCache.length === 0
     }
 
+    /**
+     * @param {string} typeToCheck
+     * @returns {boolean}
+     */
     isTypeAllowed(typeToCheck) {
         for (let pattern of this.namespaceCache) {
             if (new RegExp(pattern).test(typeToCheck.constructor.name)) {

package/lib/core/protocol/CommandDeserializer.js

@@ -1,9 +1,12 @@
+// @ts-check
 import { Command } from '../../utils/Command.js'
-import { CommandType } from '../../utils/CommandType.js'
 import { Type } from '../../utils/Type.js'
 import { TypeDeserializer } from './TypeDeserializer.js'
 
 export class CommandDeserializer {
+    /**
+     * @param {Int8Array} buffer
+     */
     constructor(buffer) {
         this.buffer = buffer
         this.command = new Command(buffer[0], buffer[10], [])
@@ -24,8 +27,14 @@ export class CommandDeserializer {
         return this.position === this.buffer.length
     }
 
+    /**
+     * @param {number} typeNum
+     * @returns {any}
+     */
     readObject(typeNum) {
-        const type = Object.entries(Type).find((entry) => entry[1] === typeNum)[0]
+        const entry = Object.entries(Type).find((entry) => entry[1] === typeNum)
+        if (!entry) throw new Error('Unknown type number: ' + typeNum)
+        const type = entry[0]
         switch (type) {
             case 'JAVONET_COMMAND':
                 return this.readCommand()