javonet-nodejs-sdk 2.0.1 → 2.0.5

package/lib/core/receiver/Receiver.js

@@ -1,16 +1,16 @@
-const Interpreter = require('../interpreter/Interpreter')
-const CommandEncoder = require('../protocol/CommandEncoder')
-const interpreter = new Interpreter()
-
-class Receiver {
-    static sendCommand(byteArray) {
-        let command = interpreter.process(byteArray)
-        let commandEncoder = new CommandEncoder()
-        return commandEncoder.encode(command, 0, 0)
-    }
-    static heartBeat(byteArray) {
-        return Int8Array.from([49, 48])
-    }
-}
-
-module.exports = Receiver
+const Interpreter = require('../interpreter/Interpreter')
+const CommandEncoder = require('../protocol/CommandEncoder')
+const interpreter = new Interpreter()
+
+class Receiver {
+    static sendCommand(byteArray) {
+        let command = interpreter.process(byteArray)
+        let commandEncoder = new CommandEncoder()
+        return commandEncoder.encode(command, 0, 0)
+    }
+    static heartBeat(byteArray) {
+        return Int8Array.from([49, 48])
+    }
+}
+
+module.exports = Receiver

package/lib/core/receiver/ReceiverNative.js

@@ -1,11 +1,11 @@
-const Receiver = require('./Receiver') 
-
-class ReceiverNative {
-    static sendCommand(messageByteArray) {
-		return Receiver.sendCommand(messageByteArray)
-    }
-
-    static heartBeat(messageByteArray) {
-        return Receiver.heartBeat(messageByteArray)
-    }
-}
+const Receiver = require('./Receiver') 
+
+class ReceiverNative {
+    static sendCommand(messageByteArray) {
+		return Receiver.sendCommand(messageByteArray)
+    }
+
+    static heartBeat(messageByteArray) {
+        return Receiver.heartBeat(messageByteArray)
+    }
+}

package/lib/core/transmitter/NodejsTransmitter.js

@@ -1,26 +1,26 @@
-const wrapper = require('./NodejsTransmitterWrapper')
-
-class NodejsTransmitter {
-
-   static sendCommand(messageArray) {
-        return wrapper.sendCommand(messageArray)
-    }
-
-    static #activate = function(email = "", licenceKey = "", proxyHost = "", proxyUserName="", proxyUserPassword="") {
-        return wrapper.activate(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword)
-    }
-
-    static activateWithLicenceFile() {
-        return this.#activate()
-    }
-
-    static activateWithCredentials(email, licenceKey) {
-        return this.#activate(email, licenceKey)
-    }
-
-    static activateWithCredentialsAndProxy(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword) {
-        return this.#activate(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword)
-    }
-}
-
-module.exports = NodejsTransmitter
+const wrapper = require('./NodejsTransmitterWrapper')
+
+class NodejsTransmitter {
+
+   static sendCommand(messageArray) {
+        return wrapper.sendCommand(messageArray)
+    }
+
+    static #activate = function(email = "", licenceKey = "", proxyHost = "", proxyUserName="", proxyUserPassword="") {
+        return wrapper.activate(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword)
+    }
+
+    static activateWithLicenceFile() {
+        return this.#activate()
+    }
+
+    static activateWithCredentials(email, licenceKey) {
+        return this.#activate(email, licenceKey)
+    }
+
+    static activateWithCredentialsAndProxy(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword) {
+        return this.#activate(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword)
+    }
+}
+
+module.exports = NodejsTransmitter

package/lib/core/transmitter/NodejsTransmitterWrapper.js

@@ -1,36 +1,36 @@
-let library;
-
-class NodejsTransmitterWrapper {
-    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(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword) {
-        this.initialize()
-        return library.activate(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword)
-    }
-
-    static sendCommand(messageArray) {
-        if (library) {
-            let result = library.sendCommand(messageArray)
-            if (Array.isArray(result)) {
-                return result
-            }
-            else {
-                throw new Error("Javonet native code error: " + result)
-            }
-        }
-        else {
-            throw new Error("Javonet not active")
-        }
-    }
-}
-
-module.exports = NodejsTransmitterWrapper
+let library;
+
+class NodejsTransmitterWrapper {
+    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(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword) {
+        this.initialize()
+        return library.activate(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword)
+    }
+
+    static sendCommand(messageArray) {
+        if (library) {
+            let result = library.sendCommand(messageArray)
+            if (Array.isArray(result)) {
+                return result
+            }
+            else {
+                throw new Error("Javonet native code error: " + result)
+            }
+        }
+        else {
+            throw new Error("Javonet not active")
+        }
+    }
+}
+
+module.exports = NodejsTransmitterWrapper

package/lib/sdk/internal/InvocationContext.js

@@ -1,108 +1,106 @@
-const Interpreter = require("../../core/interpreter/Interpreter")
-const Command = require("../../utils/Command")
-const CommandType = require("../../utils/CommandType")
-const Runtime = require("../../utils/Runtime")
-const {Handler} = require("../../core/handler/Handler");
-const CommandEncoder = require('../../core/protocol/CommandEncoder')
-
-class InvocationContext {
-    #runtime
-    #connectionType
-    #tcpAddress
-    #currentCommand
-    #responseCommand
-    #interpreter
-    #handler
-    #isExecuted
-    #resultValue
-
-    constructor(runtime, connectionType, tcpAddress, command, isExecuted = false) {
-        this.#runtime = runtime
-        this.#connectionType = connectionType
-        this.#tcpAddress = tcpAddress
-        this.#currentCommand = command
-        this.#responseCommand = null
-        this.#isExecuted = isExecuted
-        this.#interpreter = null
-        this.#handler = null
-        this.#resultValue = null
-    }
-
-    destructor() {
-        if (this.#currentCommand.commandId === CommandType.Reference) {
-            this.#currentCommand = new Command(this.#runtime, CommandType.DestructReference, this.#currentCommand.payload)
-            this.execute()
-        }
-    }
-
-    execute() {
-        this.#interpreter = new Interpreter()
-
-        if (this.#currentCommand.runtime === Runtime.Nodejs) {
-            let byteArray = new CommandEncoder().encode(this.#currentCommand, this.#connectionType, this.#tcpAddress)
-            this.#interpreter.process(byteArray)
-            this.#handler = new Handler()
-            this.#responseCommand = this.#handler.handleCommand(this.#currentCommand)
-        } else {
-            this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.#connectionType, this.#tcpAddress)
-        }
-
-        if (this.#responseCommand.commandId === CommandType.Exception) {
-            throw this.#responseCommand.payload[0]
-        }
-
-        if (this.#responseCommand.commandId === CommandType.CreateClassInstance) {
-            this.#currentCommand = this.#responseCommand
-            this.#isExecuted = true
-            return this
-        }
-
-        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#responseCommand, true)
-    }
-
-    invokeStaticMethod(...args) {
-        let localCommand = new Command(this.#runtime, CommandType.InvokeStaticMethod, args)
-        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
-    }
-
-    getStaticField(...args) {
-        let localCommand = new Command(this.#runtime, CommandType.GetStaticField, args)
-        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
-    }
-
-    setStaticField(...args) {
-        let localCommand = new Command(this.#runtime, CommandType.SetStaticField, args)
-        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
-    }
-
-    createInstance(...args) {
-        let localCommand = new Command(this.#runtime, CommandType.CreateClassInstance, args)
-        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
-    }
-
-    getInstanceField(...args) {
-        let localCommand = new Command(this.#runtime, CommandType.GetInstanceField, args)
-        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
-    }
-
-    invokeInstanceMethod(...args) {
-        let localCommand = new Command(this.#runtime, CommandType.InvokeInstanceMethod, args)
-        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
-    }
-
-    getValue() {
-        this.#resultValue = this.#currentCommand.payload[0]
-        return this.#resultValue;
-    }
-
-    #buildCommand = function(command) {
-        for (let i = 0; i < command.payload.length; i++) {
-            if (typeof (command.payload[i]) === 'InvocationContext' || command.payload[i] instanceof InvocationContext) {
-                command.payload[i] = command.payload[i].#currentCommand
-            }
-        }
-        return this.#currentCommand == null ? command : command.appendArgument(this.#currentCommand);
-    }
-}
-
+const Interpreter = require("../../core/interpreter/Interpreter")
+const Command = require("../../utils/Command")
+const CommandType = require("../../utils/CommandType")
+const Runtime = require("../../utils/Runtime")
+const {Handler} = require("../../core/handler/Handler");
+const CommandEncoder = require('../../core/protocol/CommandEncoder')
+
+class InvocationContext {
+    #runtime
+    #connectionType
+    #tcpAddress
+    #currentCommand
+    #responseCommand
+    #interpreter
+    #handler
+    #isExecuted
+    #resultValue
+
+    constructor(runtime, connectionType, tcpAddress, command, isExecuted = false) {
+        this.#runtime = runtime
+        this.#connectionType = connectionType
+        this.#tcpAddress = tcpAddress
+        this.#currentCommand = command
+        this.#responseCommand = null
+        this.#isExecuted = isExecuted
+        this.#interpreter = null
+        this.#handler = null
+        this.#resultValue = null
+    }
+
+    destructor() {
+        if (this.#currentCommand.commandId === CommandType.Reference) {
+            this.#currentCommand = new Command(this.#runtime, CommandType.DestructReference, this.#currentCommand.payload)
+            this.execute()
+        }
+    }
+
+    execute() {
+        this.#interpreter = new Interpreter()
+
+        if (this.#currentCommand.runtime === Runtime.Nodejs) {
+            this.#handler = new Handler()
+            this.#responseCommand = this.#handler.handleCommand(this.#currentCommand)
+        } else {
+            this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.#connectionType, this.#tcpAddress)
+        }
+
+        if (this.#responseCommand.commandId === CommandType.Exception) {
+            throw this.#responseCommand.payload[0]
+        }
+
+        if (this.#responseCommand.commandId === CommandType.CreateClassInstance) {
+            this.#currentCommand = this.#responseCommand
+            this.#isExecuted = true
+            return this
+        }
+
+        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#responseCommand, true)
+    }
+
+    invokeStaticMethod(...args) {
+        let localCommand = new Command(this.#runtime, CommandType.InvokeStaticMethod, args)
+        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
+    }
+
+    getStaticField(...args) {
+        let localCommand = new Command(this.#runtime, CommandType.GetStaticField, args)
+        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
+    }
+
+    setStaticField(...args) {
+        let localCommand = new Command(this.#runtime, CommandType.SetStaticField, args)
+        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
+    }
+
+    createInstance(...args) {
+        let localCommand = new Command(this.#runtime, CommandType.CreateClassInstance, args)
+        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
+    }
+
+    getInstanceField(...args) {
+        let localCommand = new Command(this.#runtime, CommandType.GetInstanceField, args)
+        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
+    }
+
+    invokeInstanceMethod(...args) {
+        let localCommand = new Command(this.#runtime, CommandType.InvokeInstanceMethod, args)
+        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
+    }
+
+    getValue() {
+        this.#resultValue = this.#currentCommand.payload[0]
+        return this.#resultValue;
+    }
+
+    #buildCommand = function(command) {
+        for (let i = 0; i < command.payload.length; i++) {
+            if (typeof (command.payload[i]) === 'InvocationContext' || command.payload[i] instanceof InvocationContext) {
+                command.payload[i] = command.payload[i].#currentCommand
+            }
+        }
+        return this.#currentCommand == null ? command : command.appendArgument(this.#currentCommand);
+    }
+}
+
 module.exports = InvocationContext

package/lib/sdk/internal/RuntimeContext.js

@@ -1,95 +1,95 @@
-const Interpreter = require("../../core/interpreter/Interpreter")
-const Command = require("../../utils/Command")
-const CommandType = require("../../utils/CommandType")
-const InvocationContext = require("./InvocationContext")
-const ConnectionType = require("../../utils/ConnectionType");
-const GeneratorHandler = require("../../core/generator/handler/GeneratorHandler");
-const Runtime = require("../../utils/Runtime");
-const {Handler} = require("../../core/handler/Handler");
-const homedir = require('os').homedir();
-
-
-class RuntimeContext {
-    #currentCommand
-    #interpreter
-    #resultValue
-    static memoryRuntimeContexts = new Map();
-    static networkRuntimeContexts = new Map();
-    generatorHandler = new GeneratorHandler();
-
-    constructor(runtime, connectionType, tcpConnectionData = null) {
-        this.runtime = runtime
-        this.connectionType = connectionType
-        this.tcpConnectionData = tcpConnectionData
-        this.#currentCommand = null
-        this.#interpreter = new Interpreter()
-    }
-
-    static getInstance(runtime, connectionType, tcpConnectionData = null) {
-        if ((ConnectionType.TCP === connectionType) && tcpConnectionData != null) {
-            if (RuntimeContext.networkRuntimeContexts.has(tcpConnectionData)) {
-                const runtimeCtx = RuntimeContext.networkRuntimeContexts.get(tcpConnectionData)
-                runtime.command = null;
-                return runtimeCtx;
-            } else {
-                const runtimeCtx = new RuntimeContext(runtime, connectionType, tcpConnectionData)
-                RuntimeContext.networkRuntimeContexts.set(tcpConnectionData, runtimeCtx)
-                return runtimeCtx
-            }
-        } else {
-            if (RuntimeContext.memoryRuntimeContexts.has(runtime)) {
-                const runtimeCtx = this.memoryRuntimeContexts.get(runtime)
-                runtimeCtx.command = null;
-                return runtimeCtx;
-            } else {
-                const runtimeCtx = new RuntimeContext(runtime, connectionType)
-                RuntimeContext.networkRuntimeContexts.set(runtime, runtimeCtx)
-                return runtimeCtx
-            }
-        }
-    }
-
-    execute(immediateCommand) {
-        this.command = this.#interpreter.execute(immediateCommand, this.connectionType, this.tcpConnectionData)
-    }
-
-    loadLibrary(...args) {
-        let localCommand = new Command(this.runtime, CommandType.LoadLibrary, args)
-        if (localCommand.runtime === Runtime.Nodejs) {
-            let handler = new Handler()
-            handler.handleCommand(localCommand)
-        } else {
-            this.execute(localCommand)
-        }
-        return this
-    }
-
-    getType(...args) {
-        let localCommand = new Command(this.runtime, CommandType.GetType, args)
-        return new InvocationContext(this.runtime, this.connectionType, this.tcpConnectionData, this.#buildCommand(localCommand))
-    }
-
-    invokeGlobalMethod(...args) {
-        let localCommand = new Command(this.runtime, CommandType.InvokeGlobalMethod, args)
-        return new InvocationContext(this.runtime, this.connectionType, this.tcpConnectionData, this.#buildCommand(localCommand))
-    }
-
-    generateLibrary(...args) {
-        let cmd = new Command(this.runtime, CommandType.GenerateLib, args)
-        this.execute(cmd);
-        this.generatorHandler.generate(this.command, homedir);
-        return this;
-    }
-
-    getValue() {
-        this.#resultValue = this.#currentCommand.payload[0]
-        return this.#resultValue;
-    }
-
-    #buildCommand = function(command) {
-        return !this.#currentCommand ? command : command.appendArgument(this.#currentCommand)
-    }
-}
-
-
+const Interpreter = require("../../core/interpreter/Interpreter")
+const Command = require("../../utils/Command")
+const CommandType = require("../../utils/CommandType")
+const InvocationContext = require("./InvocationContext")
+const ConnectionType = require("../../utils/ConnectionType");
+const GeneratorHandler = require("../../core/generator/handler/GeneratorHandler");
+const Runtime = require("../../utils/Runtime");
+const {Handler} = require("../../core/handler/Handler");
+const homedir = require('os').homedir();
+
+
+class RuntimeContext {
+    #currentCommand
+    #interpreter
+    #resultValue
+    static memoryRuntimeContexts = new Map();
+    static networkRuntimeContexts = new Map();
+    generatorHandler = new GeneratorHandler();
+
+    constructor(runtime, connectionType, tcpConnectionData = null) {
+        this.runtime = runtime
+        this.connectionType = connectionType
+        this.tcpConnectionData = tcpConnectionData
+        this.#currentCommand = null
+        this.#interpreter = new Interpreter()
+    }
+
+    static getInstance(runtime, connectionType, tcpConnectionData = null) {
+        if ((ConnectionType.TCP === connectionType) && tcpConnectionData != null) {
+            if (RuntimeContext.networkRuntimeContexts.has(tcpConnectionData)) {
+                const runtimeCtx = RuntimeContext.networkRuntimeContexts.get(tcpConnectionData)
+                runtime.command = null;
+                return runtimeCtx;
+            } else {
+                const runtimeCtx = new RuntimeContext(runtime, connectionType, tcpConnectionData)
+                RuntimeContext.networkRuntimeContexts.set(tcpConnectionData, runtimeCtx)
+                return runtimeCtx
+            }
+        } else {
+            if (RuntimeContext.memoryRuntimeContexts.has(runtime)) {
+                const runtimeCtx = this.memoryRuntimeContexts.get(runtime)
+                runtimeCtx.command = null;
+                return runtimeCtx;
+            } else {
+                const runtimeCtx = new RuntimeContext(runtime, connectionType)
+                RuntimeContext.networkRuntimeContexts.set(runtime, runtimeCtx)
+                return runtimeCtx
+            }
+        }
+    }
+
+    execute(immediateCommand) {
+        this.command = this.#interpreter.execute(immediateCommand, this.connectionType, this.tcpConnectionData)
+    }
+
+    loadLibrary(...args) {
+        let localCommand = new Command(this.runtime, CommandType.LoadLibrary, args)
+        if (localCommand.runtime === Runtime.Nodejs) {
+            let handler = new Handler()
+            handler.handleCommand(localCommand)
+        } else {
+            this.execute(localCommand)
+        }
+        return this
+    }
+
+    getType(...args) {
+        let localCommand = new Command(this.runtime, CommandType.GetType, args)
+        return new InvocationContext(this.runtime, this.connectionType, this.tcpConnectionData, this.#buildCommand(localCommand))
+    }
+
+    invokeGlobalMethod(...args) {
+        let localCommand = new Command(this.runtime, CommandType.InvokeGlobalMethod, args)
+        return new InvocationContext(this.runtime, this.connectionType, this.tcpConnectionData, this.#buildCommand(localCommand))
+    }
+
+    generateLibrary(...args) {
+        let cmd = new Command(this.runtime, CommandType.GenerateLib, args)
+        this.execute(cmd);
+        this.generatorHandler.generate(this.command, homedir);
+        return this;
+    }
+
+    getValue() {
+        this.#resultValue = this.#currentCommand.payload[0]
+        return this.#resultValue;
+    }
+
+    #buildCommand = function(command) {
+        return !this.#currentCommand ? command : command.appendArgument(this.#currentCommand)
+    }
+}
+
+
 module.exports = RuntimeContext

package/lib/sdk/internal/RuntimeContextCounter.js

@@ -1,7 +1,7 @@
-class RuntimeContextCounter {
-    CONTEXT_MAP = {}
-    CONTEXT_COUNTER = {}
-    TCP_CONTEXT_MAP = {}
-}
-
+class RuntimeContextCounter {
+    CONTEXT_MAP = {}
+    CONTEXT_COUNTER = {}
+    TCP_CONTEXT_MAP = {}
+}
+
 module.exports = new RuntimeContextCounter()