javonet-nodejs-sdk 2.5.8 → 2.5.9

package/lib/core/handler/InvokeInstanceMethodHandler.js

@@ -1,40 +1,38 @@
-const AbstractHandler = require("./AbstractHandler");
+const AbstractHandler = require('./AbstractHandler')
 
 class InvokeInstanceMethodHandler extends AbstractHandler {
-  requiredParametersCount = 2;
+    requiredParametersCount = 2
 
-  constructor() {
-    super();
-  }
+    constructor() {
+        super()
+    }
 
-  process(command) {
-    try {
-      if (command.payload.length < this.requiredParametersCount) {
-        throw new Error("Invoke Instance Method parameters mismatch");
-      }
-      const { payload } = command;
-      let instance = payload[0];
-      let methodName = payload[1];
-      let args = payload.slice(2);
-      let method = instance[methodName];
-      if (typeof method === "undefined") {
-        let methods = Object.getOwnPropertyNames(instance.__proto__).filter(
-          function (property) {
-            return typeof instance.__proto__[property] === "function";
-          }
-        );
-        let message = `Method ${methodName} not found in object. Available methods:\n`;
-        methods.forEach((methodIter) => {
-          message += `${methodIter}\n`;
-        });
-        throw new Error(message);
-      } else {
-        return Reflect.apply(method, instance, args);
-      }
-    } catch (error) {
-      throw this.process_stack_trace(error, this.constructor.name);
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Invoke Instance Method parameters mismatch')
+            }
+            const { payload } = command
+            let instance = payload[0]
+            let methodName = payload[1]
+            let args = payload.slice(2)
+            let method = instance[methodName]
+            if (typeof method === 'undefined') {
+                let methods = Object.getOwnPropertyNames(instance.__proto__).filter(function (property) {
+                    return typeof instance.__proto__[property] === 'function'
+                })
+                let message = `Method ${methodName} not found in object. Available methods:\n`
+                methods.forEach((methodIter) => {
+                    message += `${methodIter}\n`
+                })
+                throw new Error(message)
+            } else {
+                return Reflect.apply(method, instance, args)
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
     }
-  }
 }
 
-module.exports = new InvokeInstanceMethodHandler();
+module.exports = new InvokeInstanceMethodHandler()

package/lib/core/handler/InvokeStandaloneMethodHandler.js

@@ -0,0 +1,56 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class InvokeStandaloneMethodHandler extends AbstractHandler {
+    requiredParametersCount = 2
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Invoke standalone Method parameters mismatch')
+            }
+
+            const { payload } = command
+            const type = payload[0]
+            const methodName = payload[1]
+            const args = payload.slice(2)
+
+            if (typeof type === 'function') {
+                // assuming that function is exported as single (default)
+                return Reflect.apply(type, undefined, args)
+            }
+
+            if (typeof type === 'object') {
+                // assuming that function inside of multiple exports
+                const method = type[methodName]
+
+                if (typeof method === 'function') {
+                    return Reflect.apply(method, undefined, args)
+                }
+                return this.throwError(type, methodName)
+            } else {
+                throw new Error(`Function ${methodName} not found in libary.`)
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+
+    throwError(type, methodName) {
+        const methods = Object.getOwnPropertyNames(type).filter(
+            (property) => typeof type[property] === 'function'
+        )
+
+        let message = `Function ${methodName} not found in libary. Available standalone methods:\n`
+        methods.forEach((methodIter) => {
+            message += `${methodIter}\n`
+        })
+
+        throw new Error(message)
+    }
+}
+
+module.exports = new InvokeStandaloneMethodHandler()

package/lib/core/handler/InvokeStaticMethodHandler.js

@@ -1,40 +1,38 @@
-const AbstractHandler = require("./AbstractHandler");
+const AbstractHandler = require('./AbstractHandler')
 
 class InvokeStaticMethodHandler extends AbstractHandler {
-  requiredParametersCount = 2;
+    requiredParametersCount = 2
 
-  constructor() {
-    super();
-  }
+    constructor() {
+        super()
+    }
 
-  process(command) {
-    try {
-      if (command.payload.length < this.requiredParametersCount) {
-        throw new Error("Invoke Static Method parameters mismatch");
-      }
-      const { payload } = command;
-      let type = payload[0];
-      let methodName = payload[1];
-      let args = payload.slice(2);
-      let method = type[methodName];
-      if (typeof method === "undefined") {
-        let methods = Object.getOwnPropertyNames(type).filter(function (
-          property
-        ) {
-          return typeof type[property] === "function";
-        });
-        let message = `Method ${methodName} not found in class. Available methods:\n`;
-        methods.forEach((methodIter) => {
-          message += `${methodIter}\n`;
-        });
-        throw new Error(message);
-      } else {
-        return Reflect.apply(method, undefined, args);
-      }
-    } catch (error) {
-      throw this.process_stack_trace(error, this.constructor.name);
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Invoke Static Method parameters mismatch')
+            }
+            const { payload } = command
+            let type = payload[0]
+            let methodName = payload[1]
+            let args = payload.slice(2)
+            let method = type[methodName]
+            if (typeof method === 'undefined') {
+                let methods = Object.getOwnPropertyNames(type).filter(function (property) {
+                    return typeof type[property] === 'function'
+                })
+                let message = `Method ${methodName} not found in class. Available methods:\n`
+                methods.forEach((methodIter) => {
+                    message += `${methodIter}\n`
+                })
+                throw new Error(message)
+            } else {
+                return Reflect.apply(method, undefined, args)
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
     }
-  }
 }
 
-module.exports = new InvokeStaticMethodHandler();
+module.exports = new InvokeStaticMethodHandler()

package/lib/core/handler/LoadLibraryHandler.js

@@ -2,7 +2,7 @@ const AbstractHandler = require('./AbstractHandler')
 
 class LoadLibraryHandler extends AbstractHandler {
     requiredParametersCount = 1
-    static loadedLibraries = [];
+    static loadedLibraries = []
 
     constructor() {
         super()
@@ -10,9 +10,9 @@ class LoadLibraryHandler extends AbstractHandler {
 
     process(command) {
         if (command.payload.length < this.requiredParametersCount) {
-            throw new Error("Load Library parameters mismatch")
+            throw new Error('Load Library parameters mismatch')
         }
-        let {payload} = command
+        let { payload } = command
         let [lib] = payload
         let pathArray = lib.split(/[/\\]/)
         let libraryName = pathArray.length > 1 ? pathArray[pathArray.length - 1] : pathArray[0]
@@ -23,6 +23,7 @@ class LoadLibraryHandler extends AbstractHandler {
         try {
             moduleExports = require(lib)
             LoadLibraryHandler.loadedLibraries.push(lib)
+            // eslint-disable-next-line no-unused-vars
         } catch (error) {
             try {
                 moduleExports = require(`${process.cwd()}/${lib}`)

package/lib/core/handler/ResolveReferenceHandler.js

@@ -1,14 +1,13 @@
-const AbstractHandler = require("./AbstractHandler");
-const ReferenceCache = require("../referenceCache/ReferencesCache")
-
+const ReferencesCache = require('../referenceCache/ReferencesCache')
+const AbstractHandler = require('./AbstractHandler')
 class ResolveReferenceHandler extends AbstractHandler {
     constructor() {
         super()
     }
 
     process(command) {
-        return ReferenceCache.getInstance().resolveReference(command.payload[0])
+        return ReferencesCache.getInstance().resolveReference(command.payload[0])
     }
 }
 
-module.exports = new ResolveReferenceHandler()
+module.exports = new ResolveReferenceHandler()

package/lib/core/handler/SetGlobalStaticFieldHandler.js

@@ -1,44 +1,38 @@
-const AbstractHandler = require("./AbstractHandler");
+const AbstractHandler = require('./AbstractHandler')
 
 class SetGlobalStaticFieldHandler extends AbstractHandler {
-  requiredParametersCount = 2;
+    requiredParametersCount = 2
 
-  constructor() {
-    super();
-  }
+    constructor() {
+        super()
+    }
 
-  process(command) {
-    try {
-      if (command.payload.length < this.requiredParametersCount) {
-        throw new Error("Set gloabal static field parameters mismatch");
-      }
-      const { payload } = command;
-      const splitted = payload[0].split(".");
-      const value = payload[1];
-      let fieldToSet;
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Set gloabal static field parameters mismatch')
+            }
+            const { payload } = command
+            const splitted = payload[0].split('.')
+            const value = payload[1]
+            let fieldToSet
 
-      for (let i = 0; i < splitted.length; i++) {
-        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`;
-          fields.forEach((fieldIter) => {
-            message += `${fieldIter}\n`;
-          });
-          throw new Error(message);
+            for (let i = 0; i < splitted.length; i++) {
+                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`
+                    fields.forEach((fieldIter) => {
+                        message += `${fieldIter}\n`
+                    })
+                    throw new Error(message)
+                }
+                fieldToSet = !fieldToSet ? global[splitted[i]] : fieldToSet[splitted[i]]
+            }
+            fieldToSet = value
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
         }
-        fieldToSet = !fieldToSet
-          ? global[splitted[i]]
-          : fieldToSet[splitted[i]];
-      }
-      fieldToSet = value;
-    } catch (error) {
-      throw this.process_stack_trace(error, this.constructor.name);
     }
-  }
 }
 
-module.exports = new SetGlobalStaticFieldHandler();
+module.exports = new SetGlobalStaticFieldHandler()

package/lib/core/handler/SetInstanceFieldHandler.js

@@ -1,35 +1,35 @@
-const AbstractHandler = require("./AbstractHandler");
+const AbstractHandler = require('./AbstractHandler')
 
 class SetInstanceFieldHandler extends AbstractHandler {
-  requiredParametersCount = 3;
+    requiredParametersCount = 3
 
-  constructor() {
-    super();
-  }
+    constructor() {
+        super()
+    }
 
-  process(command) {
-    try {
-      if (command.payload.length < this.requiredParametersCount) {
-        throw new Error("Set Instance Field parameters mismatch");
-      }
-      const { payload } = command;
-      let instance = payload[0];
-      let field = payload[1];
-      let value = payload[2];
-      if (typeof instance[field] === "undefined") {
-        let fields = Object.keys(instance);
-        let message = `Field ${field} not found in object. Available fields:\n`;
-        fields.forEach((fieldIter) => {
-          message += `${fieldIter}\n`;
-        });
-        throw new Error(message);
-      }
-      instance[field] = value;
-      return 0;
-    } catch (error) {
-      throw this.process_stack_trace(error, this.constructor.name);
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Set Instance Field parameters mismatch')
+            }
+            const { payload } = command
+            let instance = payload[0]
+            let field = payload[1]
+            let value = payload[2]
+            if (typeof instance[field] === 'undefined') {
+                let fields = Object.keys(instance)
+                let message = `Field ${field} not found in object. Available fields:\n`
+                fields.forEach((fieldIter) => {
+                    message += `${fieldIter}\n`
+                })
+                throw new Error(message)
+            }
+            instance[field] = value
+            return 0
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
     }
-  }
 }
 
-module.exports = new SetInstanceFieldHandler();
+module.exports = new SetInstanceFieldHandler()

package/lib/core/handler/SetStaticFieldHandler.js

@@ -1,33 +1,33 @@
-const AbstractHandler = require("./AbstractHandler");
+const AbstractHandler = require('./AbstractHandler')
 
 class SetStaticFieldHandler extends AbstractHandler {
-  requiredParametersCount = 3;
+    requiredParametersCount = 3
 
-  constructor() {
-    super();
-  }
+    constructor() {
+        super()
+    }
 
-  process(command) {
-    try {
-      if (command.payload.length < this.requiredParametersCount) {
-        throw new Error("Set static field parameters mismatch");
-      }
-      const { payload } = command;
-      let [obj, field, value] = payload;
-      if (typeof obj[field] === "undefined") {
-        let fields = Object.keys(obj);
-        let message = `Field ${field} not found in class ${obj.constructor.name}. Available fields:\n`;
-        fields.forEach((fieldIter) => {
-          message += `${fieldIter}\n`;
-        });
-        throw new Error(message);
-      }
-      obj[field] = value;
-      return 0;
-    } catch (error) {
-      throw this.process_stack_trace(error, this.constructor.name);
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Set static field parameters mismatch')
+            }
+            const { payload } = command
+            let [obj, field, value] = payload
+            if (typeof obj[field] === 'undefined') {
+                let fields = Object.keys(obj)
+                let message = `Field ${field} not found in class ${obj.constructor.name}. Available fields:\n`
+                fields.forEach((fieldIter) => {
+                    message += `${fieldIter}\n`
+                })
+                throw new Error(message)
+            }
+            obj[field] = value
+            return 0
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
     }
-  }
 }
 
-module.exports = new SetStaticFieldHandler();
+module.exports = new SetStaticFieldHandler()

package/lib/core/handler/ValueHandler.js

@@ -1,15 +1,13 @@
-const AbstractHandler = require("./AbstractHandler")
-
+const AbstractHandler = require('./AbstractHandler')
 
 class ValueHandler extends AbstractHandler {
-
     constructor() {
         super()
     }
     process(command) {
-        const {payload} = command
+        const { payload } = command
         return payload[0]
     }
 }
 
-module.exports = new ValueHandler()
+module.exports = new ValueHandler()

package/lib/core/namespaceCache/NamespaceCache.js

@@ -1,39 +1,39 @@
 class NamespaceCache {
-    static _instance = null;
-    namespaceCache = [];
+    static _instance = null
+    namespaceCache = []
 
     constructor() {
         if (NamespaceCache._instance === null) {
-            NamespaceCache._instance = this;
+            NamespaceCache._instance = this
         }
-        return NamespaceCache._instance;
+        return NamespaceCache._instance
     }
 
     cacheNamespace(namespaceRegex) {
-        this.namespaceCache.push(namespaceRegex);
+        this.namespaceCache.push(namespaceRegex)
     }
 
     isNamespaceCacheEmpty() {
-        return this.namespaceCache.length === 0;
+        return this.namespaceCache.length === 0
     }
 
     isTypeAllowed(typeToCheck) {
         for (let pattern of this.namespaceCache) {
             if (new RegExp(pattern).test(typeToCheck.constructor.name)) {
-                return true;
+                return true
             }
         }
-        return false;
+        return false
     }
 
     getCachedNamespaces() {
-        return this.namespaceCache;
+        return this.namespaceCache
     }
 
     clearCache() {
-        this.namespaceCache = [];
-        return 0;
+        this.namespaceCache = []
+        return 0
     }
 }
 
-module.exports = NamespaceCache;
+module.exports = NamespaceCache

package/lib/core/receiver/Receiver.js

@@ -1,24 +1,30 @@
-const Interpreter = require('../interpreter/Interpreter')
-const CommandSerializer = require("../protocol/CommandSerializer");
-const InMemoryConnectionData = require("../../utils/connectionData/InMemoryConnectionData");
-const RuntimeLogger = require("../../utils/RuntimeLogger");
-
+const { InMemoryConnectionData, CommandSerializer, Interpreter } = require('@javonet/core')
 
+let RuntimeLogger
 
 class Receiver {
-
-    static connectionData = new InMemoryConnectionData();
+    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)
+        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
+        response[1] = messageByteArray[12] - 2
         return response
     }
 }

package/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/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/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/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