javonet-nodejs-sdk 2.5.8 → 2.5.9

package/Binaries/Nodejs/{core → lib/core}/protocol/CommandDeserializer.js

@@ -1,23 +1,20 @@
-const TypeDeserializer = require("./TypeDeserializer")
-const Command = require("../../utils/Command")
-const Type = require("../../utils/Type")
-const StringEncodingMode = require("../../utils/StringEncodingMode")
-
+const TypeDeserializer = require('./TypeDeserializer')
+const Command = require('../../utils/Command')
+const Type = require('../../utils/Type')
 
 class CommandDeserializer {
     constructor(buffer) {
         this.buffer = buffer
-        this.command = new Command(
-            buffer[0],
-            buffer[10],
-            []
-        )
+        this.command = new Command(buffer[0], buffer[10], [])
         this.position = 11
     }
 
+    /**
+     * @returns {Command}
+     */
     deserialize() {
         while (!this.isAtEnd()) {
-            this.command = this.command.addArgToPayload((this.readObject(this.buffer[this.position])))
+            this.command = this.command.addArgToPayload(this.readObject(this.buffer[this.position]))
         }
         return this.command
     }
@@ -27,7 +24,7 @@ class CommandDeserializer {
     }
 
     readObject(typeNum) {
-        let type = Object.entries(Type).find(entry => entry[1] === typeNum)[0]
+        const type = Object.entries(Type).find((entry) => entry[1] === typeNum)[0]
         switch (type) {
             case 'JAVONET_COMMAND':
                 return this.readCommand()
@@ -36,17 +33,17 @@ class CommandDeserializer {
             case 'JAVONET_INTEGER':
                 return this.readInt()
             case 'JAVONET_BOOLEAN':
-                return this.readBool();
+                return this.readBool()
             case 'JAVONET_FLOAT':
-                return this.readFloat();
+                return this.readFloat()
             case 'JAVONET_BYTE':
-                return this.readByte();
+                return this.readByte()
             case 'JAVONET_CHAR':
-                return this.readChar();
+                return this.readChar()
             case 'JAVONET_LONG_LONG':
-                return this.readLongLong();
+                return this.readLongLong()
             case 'JAVONET_DOUBLE':
-                return this.readDouble();
+                return this.readDouble()
             case 'JAVONET_UNSIGNED_LONG_LONG':
                 return this.readUllong
             case 'JAVONET_UNSIGNED_INTEGER':
@@ -59,112 +56,110 @@ class CommandDeserializer {
     }
 
     readCommand() {
-        let p = this.position
-        let numberOfElementsInPayload = TypeDeserializer.deserializeInt(this.buffer.slice(p + 1, p + 5))
-        let runtime = this.buffer[p + 5]
-        let type = this.buffer[p + 6]
+        const p = this.position
+        const numberOfElementsInPayload = TypeDeserializer.deserializeInt(this.buffer.slice(p + 1, p + 5))
+        const runtime = this.buffer[p + 5]
+        const type = this.buffer[p + 6]
         this.position += 7
-        let command = new Command(runtime, type, [])
+        const command = new Command(runtime, type, [])
         return this.readCommandRecursively(numberOfElementsInPayload, command)
     }
 
     readCommandRecursively(numberOfElementsInPayloadLeft, cmd) {
         if (numberOfElementsInPayloadLeft === 0) return cmd
-        let p = this.position
+        const p = this.position
         cmd = cmd.addArgToPayload(this.readObject(this.buffer[p]))
         return this.readCommandRecursively(numberOfElementsInPayloadLeft - 1, cmd)
     }
 
     readString() {
         let p = this.position
-        let stringEncodingMode = this.buffer[p + 1]
-        let size = TypeDeserializer.deserializeInt(this.buffer.slice(p + 2, p + 6))
+        const stringEncodingMode = this.buffer[p + 1]
+        const size = TypeDeserializer.deserializeInt(this.buffer.slice(p + 2, p + 6))
         this.position += 6
         p = this.position
         this.position += size
         return TypeDeserializer.deserializeString(stringEncodingMode, this.buffer.slice(p, p + size))
-
     }
 
     readInt() {
-        let size = 4
+        const size = 4
         this.position += 2
-        let p = this.position
+        const p = this.position
         this.position += size
         return TypeDeserializer.deserializeInt(this.buffer.slice(p, p + size))
     }
 
     readBool() {
-        let size = 1
+        const size = 1
         this.position += 2
-        let p = this.position
+        const p = this.position
         this.position += size
         return TypeDeserializer.deserializeBool(this.buffer.slice(p, p + size))
     }
 
     readFloat() {
-        let size = 4
+        const size = 4
         this.position += 2
-        let p = this.position
+        const p = this.position
         this.position += size
         return TypeDeserializer.deserializeFloat(this.buffer.slice(p, p + size))
     }
 
     readByte() {
-        let size = 1
+        const size = 1
         this.position += 2
-        let p = this.position
+        const p = this.position
         this.position += size
         return TypeDeserializer.deserializeByte(this.buffer.slice(p, p + size))
     }
 
     readChar() {
-        let size = 1
+        const size = 1
         this.position += 2
-        let p = this.position
+        const p = this.position
         this.position += size
         return TypeDeserializer.deserializeChar(this.buffer.slice(p, p + size))
     }
 
     readLongLong() {
-        let size = 8
+        const size = 8
         this.position += 2
-        let p = this.position
+        const p = this.position
         this.position += size
         return TypeDeserializer.deserializeLongLong(this.buffer.slice(p, p + size))
     }
 
     readDouble() {
-        let size = 8
+        const size = 8
         this.position += 2
-        let p = this.position
+        const p = this.position
         this.position += size
         return TypeDeserializer.deserializeDouble(this.buffer.slice(p, p + size))
     }
 
     readUllong() {
-        let size = 8
+        const size = 8
         this.position += 2
-        let p = this.position
+        const p = this.position
         this.position += size
         return TypeDeserializer.deserializeULLong(this.buffer.slice(p, p + size))
     }
 
     readUInt() {
-        let size = 4
+        const size = 4
         this.position += 2
-        let p = this.position
+        const p = this.position
         this.position += size
         return TypeDeserializer.deserializeUInt(this.buffer.slice(p, p + size))
     }
 
     readNull() {
-        let size = 1
+        const size = 1
         this.position += 2
-        let p = this.position
         this.position += size
         return TypeDeserializer.deserializeNull()
     }
 }
 
-module.exports = CommandDeserializer
+module.exports = CommandDeserializer

package/Binaries/Nodejs/{core → lib/core}/protocol/CommandSerializer.js

@@ -1,11 +1,10 @@
-const Command = require("../../utils/Command")
+const Command = require('../../utils/Command')
 const TypeEncoder = require('./TypeSerializer')
 const Runtime = require('../../utils/RuntimeName')
 
 class CommandSerializer {
     buffer = new Int8Array(2)
 
-
     serialize(root_command, connectionData, runtimeVersion = 0) {
         this.buffer[0] = root_command.runtimeName
         this.buffer[1] = runtimeVersion
@@ -15,7 +14,7 @@ class CommandSerializer {
         return this.buffer
     }
 
-    #serializeRecursively = function(root_command) {
+    #serializeRecursively = function (root_command) {
         for (let cmd of root_command.payload) {
             if (cmd instanceof Command) {
                 this.#insertIntoBuffer(TypeEncoder.serializeCommand(cmd))
@@ -27,7 +26,7 @@ class CommandSerializer {
         }
     }
 
-    #insertIntoBuffer = function(arg) {
+    #insertIntoBuffer = function (arg) {
         let newArray = new Int8Array(this.buffer.length + arg.length)
         newArray.set(this.buffer, 0)
         newArray.set(arg, this.buffer.length)
@@ -35,4 +34,4 @@ class CommandSerializer {
     }
 }
 
-module.exports = CommandSerializer
+module.exports = CommandSerializer

package/Binaries/Nodejs/{core → lib/core}/protocol/TypeDeserializer.js

@@ -1,7 +1,6 @@
 const Command = require('../../utils/Command')
-const Type = require('../../utils/Type')
 const StringEncodingMode = require('../../utils/StringEncodingMode')
-const {TextDecoder} = require("util");
+const { Buffer } = require('buffer')
 
 class TypeDeserializer {
     static deserializeCommand(encodedCommand) {
@@ -12,11 +11,12 @@ class TypeDeserializer {
         switch (stringEncodingMode) {
             case StringEncodingMode.ASCII:
                 return String.fromCharCode(...encodedString)
-            case StringEncodingMode.UTF8:
-                let decoder = new TextDecoder('UTF-8');
+            case StringEncodingMode.UTF8: {
+                const decoder = new TextDecoder('UTF-8')
                 return decoder.decode(new Uint8Array(encodedString))
-            case StringEncodingMode.UTF16:
-                let str = "";
+            }
+            case StringEncodingMode.UTF16: {
+                let str = ''
                 let newBuffer = new Uint8Array(encodedString)
                 for (let i = 0; i < newBuffer.length; i++) {
                     newBuffer[i] = encodedString[i]
@@ -24,20 +24,21 @@ class TypeDeserializer {
                 for (let i = 0; i < encodedString.length; i = i + 2) {
                     str += String.fromCharCode(newBuffer[i] + 256 * newBuffer[i + 1])
                 }
-                return str;
+                return str
+            }
             case StringEncodingMode.UTF32:
-                throw "Type utf32-encoded string not supported in JavaScript"
+                throw 'Type utf32-encoded string not supported in JavaScript'
             default:
-                throw "Unknown string encoding - not supported in JavaScript";
+                throw 'Unknown string encoding - not supported in JavaScript'
         }
     }
 
     static deserializeInt(encodedInt) {
         return (
-            (encodedInt[0] & 0xFF)
-            | ((encodedInt[1] & 0xFF) << 8)
-            | ((encodedInt[2] & 0xFF) << 16)
-            | ((encodedInt[3] & 0xFF) << 24)
+            (encodedInt[0] & 0xff) |
+            ((encodedInt[1] & 0xff) << 8) |
+            ((encodedInt[2] & 0xff) << 16) |
+            ((encodedInt[3] & 0xff) << 24)
         )
     }
 
@@ -73,8 +74,9 @@ class TypeDeserializer {
         return Buffer.from(encodedUInt).readUIntLE(0, 4)
     }
 
-    static deserializeNull(encodedNull) {
-        return null;
+    // eslint-disable-next-line no-unused-vars
+    static deserializeNull(encodedNull = null) {
+        return null
     }
 }
 

package/Binaries/Nodejs/{core → lib/core}/protocol/TypeSerializer.js

@@ -1,27 +1,26 @@
 const Command = require('../../utils/Command')
 const Type = require('../../utils/Type')
 const StringEncodingMode = require('../../utils/StringEncodingMode')
+const { Buffer } = require('buffer')
 
-const util = require('util');
-let encoder = new util.TextEncoder();
+const encoder = new TextEncoder()
 
 class TypeSerializer {
-
     static encodePrimitive(payload_item) {
         if (payload_item === null) {
             return TypeSerializer.serializeNull()
         }
         if (payload_item instanceof Command) {
             return TypeSerializer.serializeCommand(payload_item)
-        } else if (typeof (payload_item) === 'number' || payload_item instanceof Number) {
+        } else if (typeof payload_item === 'number' || payload_item instanceof Number) {
             if (Number.isInteger(payload_item)) {
                 return TypeSerializer.serializeInt(payload_item)
             } else {
                 return TypeSerializer.serializeDouble(payload_item)
             }
-        } else if (typeof (payload_item) === 'string' || payload_item instanceof String) {
+        } else if (typeof payload_item === 'string' || payload_item instanceof String) {
             return TypeSerializer.serializeString(payload_item)
-        } else if (typeof (payload_item) === 'boolean' || payload_item instanceof Boolean) {
+        } else if (typeof payload_item === 'boolean' || payload_item instanceof Boolean) {
             return TypeSerializer.serializeBool(payload_item)
         } else {
             throw 'Unknown type - not supported in JavaScript'
@@ -134,4 +133,4 @@ class TypeSerializer {
     }
 }
 
-module.exports = TypeSerializer
+module.exports = TypeSerializer

package/Binaries/Nodejs/lib/core/receiver/Receiver.js

@@ -0,0 +1,32 @@
+const { InMemoryConnectionData, CommandSerializer, Interpreter } = require('../../..')
+
+let RuntimeLogger
+
+class Receiver {
+    static connectionData = new InMemoryConnectionData()
+    Receiver() {
+        if (!RuntimeLogger) {
+            RuntimeLogger = require('../../utils/RuntimeLogger')
+        }
+        RuntimeLogger.printRuntimeInfo()
+    }
+
+    /**
+     * @param {number[]} messageByteArray
+     */
+    static sendCommand(messageByteArray) {
+        return new CommandSerializer().serialize(
+            new Interpreter().process(messageByteArray),
+            this.connectionData
+        )
+    }
+
+    static heartBeat(messageByteArray) {
+        let response = new Int8Array(2)
+        response[0] = messageByteArray[11]
+        response[1] = messageByteArray[12] - 2
+        return response
+    }
+}
+
+module.exports = Receiver

package/Binaries/Nodejs/{core → lib/core}/receiver/ReceiverNative.js

@@ -1,8 +1,8 @@
-const Receiver = require('./Receiver') 
+const Receiver = require('./Receiver')
 
 class ReceiverNative {
     static sendCommand(messageByteArray) {
-		return Receiver.sendCommand(messageByteArray)
+        return Receiver.sendCommand(messageByteArray)
     }
 
     static heartBeat(messageByteArray) {
@@ -10,4 +10,4 @@ class ReceiverNative {
     }
 }
 
-global.ReceiverNative = ReceiverNative;
+global.ReceiverNative = ReceiverNative

package/Binaries/Nodejs/{core → lib/core}/referenceCache/ReferencesCache.js

@@ -1,9 +1,9 @@
+const v4 = require('../../utils/uuid/v4')
+
 let _cache = {}
 let _instance = null
-const v4 = require('../../utils/uuid/v4')
 
 class ReferencesCache {
-
     static getInstance() {
         if (_instance === null) {
             _instance = new ReferencesCache()
@@ -23,8 +23,8 @@ class ReferencesCache {
 
     deleteReference(referenceGuid) {
         delete _cache[referenceGuid]
-        return 0;
+        return 0
     }
 }
 
-module.exports = ReferencesCache
+module.exports = ReferencesCache

package/Binaries/Nodejs/{core → lib/core}/transmitter/Transmitter.js

@@ -1,16 +1,15 @@
 const wrapper = require('./TransmitterWrapper')
 
 class Transmitter {
-
     static initialize() {
         return wrapper.initialize()
     }
 
-   static sendCommand(messageArray) {
+    static sendCommand(messageArray) {
         return wrapper.sendCommand(messageArray)
     }
 
-    static activate = function(licenseKey) {
+    static activate = function (licenseKey) {
         return wrapper.activate(licenseKey)
     }
 

package/Binaries/Nodejs/lib/core/transmitter/TransmitterWebsocket.js

@@ -0,0 +1,33 @@
+const WebSocketClient = require('../webSocketClient/WebSocketClient')
+
+/** @typedef {import('../../../../core/lib/declarations').WsConnectionData} WsConnectionData */
+
+class TransmitterWebsocket {
+    /**
+     * @returns {void}
+     */
+    static initialize() {}
+
+    /**
+     * @returns {void}
+     */
+    static setConfigSource() {}
+
+    /**
+     * @returns {void}
+     */
+    static activate() {}
+
+    /**
+     * @async
+     * @param {number[]} messageByteArray
+     * @param {WsConnectionData} connectionData
+     * @returns {Promise<number[]>} responseByteArray
+     */
+    static async sendCommand(messageByteArray, connectionData) {
+        const { hostname } = connectionData
+        return new WebSocketClient(hostname).send(messageByteArray)
+    }
+}
+
+module.exports = TransmitterWebsocket

package/Binaries/Nodejs/lib/core/transmitter/TransmitterWrapper.js

@@ -0,0 +1,34 @@
+let library
+
+class TransmitterWrapper {
+    static initialize() {
+        if (process.platform === 'win32')
+            library = require(
+                `${require('path').resolve(__dirname, '../../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`
+            )
+        else if (process.platform === 'darwin')
+            library = require(
+                `${require('path').resolve(__dirname, '../../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`
+            )
+        else
+            library = require(
+                `${require('path').resolve(__dirname, '../../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`
+            )
+        let binariesRootPath = String(`${require('path').resolve(__dirname, '../../../../')}`)
+        return library.initializeTransmitter(binariesRootPath)
+    }
+
+    static activate(licenseKey) {
+        return library.activate(licenseKey)
+    }
+
+    static sendCommand(messageArray) {
+        return library.sendCommand(messageArray)
+    }
+
+    static setConfigSource(configSource) {
+        return library.setConfigSource(configSource)
+    }
+}
+
+module.exports = TransmitterWrapper

package/Binaries/Nodejs/{core → lib/core}/typeCache/TypeCache.js

@@ -1,39 +1,39 @@
 class TypeCache {
-    static _instance = null;
-    typeCache = [];
+    static _instance = null
+    typeCache = []
 
     constructor() {
         if (TypeCache._instance === null) {
-            TypeCache._instance = this;
+            TypeCache._instance = this
         }
-        return TypeCache._instance;
+        return TypeCache._instance
     }
 
     cacheType(typRegex) {
-        this.typeCache.push(typRegex);
+        this.typeCache.push(typRegex)
     }
 
     isTypeCacheEmpty() {
-        return this.typeCache.length === 0;
+        return this.typeCache.length === 0
     }
 
     isTypeAllowed(typeToCheck) {
         for (let pattern of this.typeCache) {
             if (new RegExp(pattern).test(typeToCheck.name)) {
-                return true;
+                return true
             }
         }
-        return false;
+        return false
     }
 
     getCachedTypes() {
-        return this.typeCache;
+        return this.typeCache
     }
 
     clearCache() {
-        this.typeCache = [];
-        return 0;
+        this.typeCache = []
+        return 0
     }
 }
 
-module.exports = TypeCache;
+module.exports = TypeCache