javonet-nodejs-sdk 2.5.8 → 2.5.10

package/lib/core/handler/PassDelegateHandler.js

@@ -0,0 +1,157 @@
+// eslint-disable-next-line no-unused-vars
+const { Interpreter, Command, CommandType, InMemoryConnectionData, DelegatesCache } = require('@javonet/core')
+const AbstractHandler = require('./AbstractHandler')
+
+/**
+ * PassDelegateHandler class responsible for processing a command to create a delegate.
+ */
+class PassDelegateHandler extends AbstractHandler {
+    constructor() {
+        super()
+        /**
+         * Minimum required parameters count for the command.
+         * @type {number}
+         */
+        this.requiredParametersCount = 1
+        this.interpreter = new Interpreter()
+    }
+
+    /**
+     * Processes the given command to create and compile a delegate.
+     * @param {Command} command - The command to process.
+     * @returns {Function} The compiled delegate function.
+     */
+    process(command) {
+        this.validateCommand(command)
+
+        const delegateGuid = command.payload[0]
+        const delegate = DelegatesCache.getDelegate(delegateGuid)
+
+        return delegate
+    }
+
+    /**
+     * Validates the command to ensure it has enough parameters.
+     * @param {Command} command - The command to validate.
+     */
+    validateCommand(command) {
+        if (command.payload.length < this.requiredParametersCount) {
+            throw new Error('PassDelegateHandler parameters mismatch')
+        }
+    }
+
+    /**
+     * Retrieves the arguments from the command payload.
+     * @param {Command} command - The command containing the payload.
+     * @returns {Array} The extracted arguments.
+     */
+    getArguments(command) {
+        return command.payload.length > 2 ? command.payload.slice(2) : []
+    }
+
+    /**
+     * Extracts argument types from the arguments array.
+     * @param {Array} args - The arguments array.
+     * @returns {Array} The argument types.
+     */
+    getArgumentTypes(args) {
+        return args.slice(0, -1).map((arg) => arg.constructor)
+    }
+
+    /**
+     * Retrieves the return type from the arguments array.
+     * @param {Array} args - The arguments array.
+     * @returns {Function} The return type.
+     */
+    getReturnType(args) {
+        return args[args.length - 1].constructor
+    }
+
+    /**
+     * Creates parameter expressions from argument types.
+     * @param {Array} argsTypes - The argument types.
+     * @returns {Array} The parameter expressions.
+     */
+    createParameters(argsTypes) {
+        return argsTypes.map((type, index) => ({ name: `arg${index}`, type }))
+    }
+
+    /**
+     * Creates an array of arguments for the delegate.
+     * @param {string} delegateGuid - The delegate identifier.
+     * @param {Array} parameters - The parameter expressions.
+     * @returns {Array} The arguments array.
+     */
+    createArgsArray(delegateGuid, parameters) {
+        return [delegateGuid, ...parameters.map((param) => param.name)]
+    }
+
+    /**
+     * Creates a command expression.
+     * @param {string} callingRuntimeName - The runtime name.
+     * @param {Array} payload - The arguments array.
+     * @returns {Object} The command object.
+     */
+    createCommand(callingRuntimeName, payload) {
+        return {
+            runtimeName: callingRuntimeName,
+            type: CommandType.InvokeDelegate,
+            payload,
+        }
+    }
+
+    /**
+     * Creates a method call to execute the command.
+     * @param {Command} command - The command object.
+     * @returns {Object} The response object.
+     */
+    createExecuteCall(command) {
+        return this.interpreter.execute(command, new InMemoryConnectionData())
+    }
+
+    /**
+     * Retrieves the response payload from the execution call.
+     * @param {Object} executeCall - The execution call.
+     * @returns {Array} The response payload.
+     */
+    getResponse(executeCall) {
+        return executeCall.payload
+    }
+
+    /**
+     * Converts the first element of the response to the return type.
+     * @param {Array} response - The response payload.
+     * @param {Function} returnType - The return type.
+     * @returns {*} The converted first element.
+     */
+    convertFirstElement(response, returnType) {
+        return returnType(response[0])
+    }
+
+    /**
+     * Creates a block of expressions for the delegate.
+     * @param {Function} returnType - The return type.
+     * @param {*} convertedFirstElement - The converted first element.
+     * @returns {Object} The block expression.
+     */
+    createBlock(returnType, convertedFirstElement) {
+        return { returnType, body: convertedFirstElement }
+    }
+
+    /**
+     * Creates a delegate type.
+     * @param {Array} parameters - The parameter expressions.
+     * @param {Function} returnType - The return type.
+     * @returns {Function} The delegate type.
+     */
+    createDelegateType(parameters, returnType) {
+        return (...args) => {
+            if (args.length !== parameters.length) {
+                throw new Error('Invalid argument count.')
+            }
+            return returnType
+        }
+    }
+}
+
+module.exports = new PassDelegateHandler()

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

package/lib/core/transmitter/TransmitterWrapper.js

@@ -1,14 +1,20 @@
-let library;
+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`)
+        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, '../../../')}`)
+            library = require(
+                `${require('path').resolve(__dirname, '../../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`
+            )
+        let binariesRootPath = String(`${require('path').resolve(__dirname, '../../../../')}`)
         return library.initializeTransmitter(binariesRootPath)
     }
 

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