javonet-nodejs-sdk 2.1.11 → 2.1.13

package/Binaries/Native/Linux/X64/NetVersion80LatestPatch.runtimeconfig.json

@@ -0,0 +1,10 @@
+{
+  "runtimeOptions": {
+    "tfm": "net8.0",
+    "rollForward": "LatestPatch",
+    "framework": {
+      "name": "Microsoft.NETCore.App",
+      "version": "8.0.0"
+    }
+  }
+}

package/Binaries/Native/Linux/X64/NetVersionLatest.runtimeconfig.json

@@ -1,10 +1,10 @@
 {
   "runtimeOptions": {
-    "tfm": "netcoreapp3.1",
+    "tfm": "net6.0",
     "rollForward": "LatestMajor",
     "framework": {
       "name": "Microsoft.NETCore.App",
-      "version": "3.1.0"
+      "version": "6.0.0"
     }
   }
 }

package/Binaries/Native/MacOs/X64/NetVersion80LatestPatch.runtimeconfig.json

@@ -0,0 +1,10 @@
+{
+  "runtimeOptions": {
+    "tfm": "net8.0",
+    "rollForward": "LatestPatch",
+    "framework": {
+      "name": "Microsoft.NETCore.App",
+      "version": "8.0.0"
+    }
+  }
+}

package/Binaries/Native/MacOs/X64/NetVersionLatest.runtimeconfig.json

@@ -1,10 +1,10 @@
 {
   "runtimeOptions": {
-    "tfm": "netcoreapp3.1",
+    "tfm": "net6.0",
     "rollForward": "LatestMajor",
     "framework": {
       "name": "Microsoft.NETCore.App",
-      "version": "3.1.0"
+      "version": "6.0.0"
     }
   }
 }

package/Binaries/Native/Windows/X64/NetVersion80LatestPatch.runtimeconfig.json

@@ -0,0 +1,10 @@
+{
+  "runtimeOptions": {
+    "tfm": "net8.0",
+    "rollForward": "LatestPatch",
+    "framework": {
+      "name": "Microsoft.NETCore.App",
+      "version": "8.0.0"
+    }
+  }
+}

package/Binaries/Native/Windows/X64/NetVersionLatest.runtimeconfig.json

@@ -1,10 +1,10 @@
 {
   "runtimeOptions": {
-    "tfm": "netcoreapp3.1",
+    "tfm": "net6.0",
     "rollForward": "LatestMajor",
     "framework": {
       "name": "Microsoft.NETCore.App",
-      "version": "3.1.0"
+      "version": "6.0.0"
     }
   }
 }

package/Binaries/Nodejs/Linux/X64/core/handler/ArraySetItemHandler.js

@@ -15,12 +15,12 @@ class ArraySetItemHandler extends AbstractHandler {
             }
 
             let array = command.payload[0]
-            let value = command.payload[1]
+            let value = command.payload[2]
             let indexes
-            if (Array.isArray(command.payload[2])) {
-                indexes = command.payload[2]
+            if (Array.isArray(command.payload[1])) {
+                indexes = command.payload[1]
             } else {
-                indexes = command.payload.slice(2)
+                indexes = [command.payload[1]]
             }
 
             if (indexes.length === 1) {

package/Binaries/Nodejs/Linux/X64/core/handler/GetTypeHandler.js

@@ -16,7 +16,7 @@ class GetTypeHandler extends AbstractHandler {
             let typeName = payload[0]
             typeName = typeName.replace(".js", "")
             let type = global[typeName]
-            if (type == undefined) {
+            if (type === undefined) {
                 throw new Error(`Cannot load ${typeName}`)
             } else {
                 return type

package/Binaries/Nodejs/Linux/X64/core/handler/ValueHandler.js

@@ -2,6 +2,10 @@ const AbstractHandler = require("./AbstractHandler")
 
 
 class ValueHandler extends AbstractHandler {
+
+    constructor() {
+        super()
+    }
     process(command) {
         const {payload} = command
         return payload[0]

package/Binaries/Nodejs/Linux/X64/core/interpreter/Interpreter.js

@@ -1,21 +1,27 @@
 const { Handler } = require('../handler/Handler')
-const CommandEncoder = require('../protocol/CommandEncoder')
-const CommandDecoder = require('../protocol/CommandDecoder')
+const CommandSerializer = require('../protocol/CommandSerializer')
+const CommandDeserializer = require('../protocol/CommandDeserializer')
 const Runtime = require("../../utils/RuntimeName");
 
 let Transmitter
+let Receiver
 
 class Interpreter {
     handler = new Handler()
 
     execute(command, connectionType, tcpAddress) {
-        let commandEncoder = new CommandEncoder()
-        let byteMessage = commandEncoder.encode(command,connectionType, tcpAddress)
+        let commandSerializer = new CommandSerializer()
+        let byteMessage = commandSerializer.serialize(command,connectionType, tcpAddress)
         let responseByteArray
 
         if (command.runtimeName === Runtime.Nodejs)
         {
-            return this.process(byteMessage)
+            // lazy receiver loading
+            if (!Receiver) {
+                Receiver = require('../receiver/Receiver')
+            }
+            responseByteArray = Receiver.sendCommand(byteMessage)
+
         }
         else {
             // lazy transmitter loading
@@ -23,14 +29,16 @@ class Interpreter {
                 Transmitter = require('../transmitter/Transmitter')
             }
             responseByteArray = Transmitter.sendCommand(byteMessage)
-            return new CommandDecoder(responseByteArray).decode()
         }
+        return new CommandDeserializer(responseByteArray).deserialize()
     }
 
     process(byteArray) {
-        let decoder = new CommandDecoder(byteArray)
-        let command = decoder.decode()
-        return this.handler.handleCommand(command)
+        let commandDeserializer = new CommandDeserializer(byteArray)
+        let receivedCommand = commandDeserializer.deserialize()
+        let responseCommand = this.handler.handleCommand(receivedCommand)
+        let commandSerializer = new CommandSerializer()
+        return commandSerializer.serialize(responseCommand, 0, "0.0.0.0:0")
     }
 }
 

package/Binaries/Nodejs/Linux/X64/core/protocol/CommandDeserializer.js

@@ -0,0 +1,160 @@
+const TypeDeserializer = require("./TypeDeserializer")
+const Command = require("../../utils/Command")
+const Type = require("../../utils/Type")
+const StringEncodingMode = require("../../utils/StringEncodingMode")
+
+
+class CommandDeserializer {
+    constructor(buffer) {
+        this.buffer = buffer
+        this.command = new Command(
+            buffer[0],
+            buffer[10],
+            []
+        )
+        this.position = 11
+    }
+
+    deserialize() {
+        while (!this.isAtEnd()) {
+            this.command = this.command.addArgToPayload((this.readObject(this.buffer[this.position])))
+        }
+        return this.command
+    }
+
+    isAtEnd() {
+        return this.position === this.buffer.length
+    }
+
+    readObject(typeNum) {
+        let type = Object.entries(Type).find(entry => entry[1] === typeNum)[0]
+        switch (type) {
+            case 'JAVONET_COMMAND':
+                return this.readCommand()
+            case 'JAVONET_STRING':
+                return this.readString()
+            case 'JAVONET_INTEGER':
+                return this.readInt()
+            case 'JAVONET_BOOLEAN':
+                return this.readBool();
+            case 'JAVONET_FLOAT':
+                return this.readFloat();
+            case 'JAVONET_BYTE':
+                return this.readByte();
+            case 'JAVONET_CHAR':
+                return this.readChar();
+            case 'JAVONET_LONG_LONG':
+                return this.readLongLong();
+            case 'JAVONET_DOUBLE':
+                return this.readDouble();
+            case 'JAVONET_UNSIGNED_LONG_LONG':
+                return this.readUllong
+            case 'JAVONET_UNSIGNED_INTEGER':
+                return this.readUInt()
+            default:
+                throw 'Unknown type - not supported in JavaScript'
+        }
+    }
+
+    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]
+        this.position += 7
+        let command = new Command(runtime, type, [])
+        return this.readCommandRecursively(numberOfElementsInPayload, command)
+    }
+
+    readCommandRecursively(numberOfElementsInPayloadLeft, cmd) {
+        if (numberOfElementsInPayloadLeft === 0) return cmd
+        let 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))
+        this.position += 6
+        p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeString(stringEncodingMode, this.buffer.slice(p, p + size))
+
+    }
+
+    readInt() {
+        let size = 4
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeInt(this.buffer.slice(p, p + size))
+    }
+
+    readBool() {
+        let size = 1
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeBool(this.buffer.slice(p, p + size))
+    }
+
+    readFloat() {
+        let size = 4
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeFloat(this.buffer.slice(p, p + size))
+    }
+
+    readByte() {
+        let size = 1
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeByte(this.buffer.slice(p, p + size))
+    }
+
+    readChar() {
+        let size = 1
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeChar(this.buffer.slice(p, p + size))
+    }
+
+    readLongLong() {
+        let size = 8
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeLongLong(this.buffer.slice(p, p + size))
+    }
+
+    readDouble() {
+        let size = 8
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeDouble(this.buffer.slice(p, p + size))
+    }
+
+    readUllong() {
+        let size = 8
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeULLong(this.buffer.slice(p, p + size))
+    }
+
+    readUInt() {
+        let size = 4
+        this.position += 2
+        let p = this.position
+        this.position += size
+        return TypeDeserializer.deserializeUInt(this.buffer.slice(p, p + size))
+    }
+}
+
+module.exports = CommandDeserializer

package/Binaries/Nodejs/Linux/X64/core/protocol/{CommandEncoder.js → CommandSerializer.js}

@@ -1,13 +1,13 @@
 const Command = require("../../utils/Command")
-const TypeEncoder = require('./TypeEncoder')
+const TypeEncoder = require('./TypeSerializer')
 const ConnectionType = require("../../utils/ConnectionType");
 const Runtime = require('../../utils/RuntimeName')
 
-class CommandEncoder {
+class CommandSerializer {
     buffer = new Int8Array(2)
     encodedTcp;
 
-    encode(command, connectionType, tcpConnectionData, runtimeVersion = 0) {
+    serialize(command, connectionType, tcpConnectionData, runtimeVersion = 0) {
         let deque = [command]
         this.buffer[0] = command.runtimeName
         this.buffer[1] = runtimeVersion
@@ -48,7 +48,7 @@ class CommandEncoder {
         if (cmd.payload.length > 0) {
             if (cmd.payload[0] instanceof Command) {
                 let innerCommand = cmd.payload[0]
-                this.#insertIntoBuffer(TypeEncoder.encodeCommand(innerCommand))
+                this.#insertIntoBuffer(TypeEncoder.serializeCommand(innerCommand))
                 deque.push(innerCommand)
             } else {
                 let result = TypeEncoder.encodePrimitive(cmd.payload[0])
@@ -69,4 +69,4 @@ class CommandEncoder {
     }
 }
 
-module.exports = CommandEncoder
+module.exports = CommandSerializer

package/Binaries/Nodejs/Linux/X64/core/protocol/TypeDeserializer.js

@@ -0,0 +1,77 @@
+const Command = require('../../utils/Command')
+const Type = require('../../utils/Type')
+const StringEncodingMode = require('../../utils/StringEncodingMode')
+const {TextDecoder} = require("util");
+
+class TypeDeserializer {
+    static deserializeCommand(encodedCommand) {
+        return new Command(encodedCommand[0], encodedCommand[1], [])
+    }
+
+    static deserializeString(stringEncodingMode, encodedString) {
+        switch (stringEncodingMode) {
+            case StringEncodingMode.ASCII:
+                return String.fromCharCode(...encodedString)
+            case StringEncodingMode.UTF8:
+                let decoder = new TextDecoder('UTF-8');
+                return decoder.decode(new Uint8Array(encodedString))
+            case StringEncodingMode.UTF16:
+                let str = "";
+                let newBuffer = new Uint8Array(encodedString)
+                for (let i = 0; i < newBuffer.length; i++) {
+                    newBuffer[i] = encodedString[i]
+                }
+                for (let i = 0; i < encodedString.length; i = i + 2) {
+                    str += String.fromCharCode(newBuffer[i] + 256 * newBuffer[i + 1])
+                }
+                return str;
+            case StringEncodingMode.UTF32:
+                throw "Type utf32-encoded string not supported in JavaScript"
+            default:
+                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)
+        )
+    }
+
+    static deserializeBool(encodedBool) {
+        return encodedBool[0] === 1
+    }
+
+    static deserializeFloat(encodedFloat) {
+        return Buffer.from(encodedFloat).readFloatLE()
+    }
+
+    static deserializeByte(encodedByte) {
+        return Buffer.from(encodedByte).readUint8()
+    }
+
+    static deserializeChar(encodedChar) {
+        return Buffer.from(encodedChar).readUint8()
+    }
+
+    static deserializeLongLong(encodedLongLong) {
+        return Buffer.from(encodedLongLong).readBigInt64LE()
+    }
+
+    static deserializeDouble(encodedDouble) {
+        return Buffer.from(encodedDouble).readDoubleLE()
+    }
+
+    static deserializeULLong(encodedULLong) {
+        return Buffer.from(encodedULLong).readBigUInt64LE()
+    }
+
+    static deserializeUInt(encodedUInt) {
+        return Buffer.from(encodedUInt).readUIntLE(0, 4)
+    }
+}
+
+module.exports = TypeDeserializer