javonet-ruby-sdk 2.5.15 → 2.5.17

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/protocol/CommandDeserializer.js

@@ -1,181 +0,0 @@
-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.position = 11
-    }
-
-    /**
-     * @returns {Command}
-     */
-    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) {
-        const 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()
-            case 'JAVONET_NULL':
-                return this.readNull()
-            default:
-                throw 'Unknown type - not supported in JavaScript'
-        }
-    }
-
-    readCommand() {
-        const p = this.position;
-        const numberOfElementsInPayload = TypeDeserializer.deserializeInt(this.buffer.slice(p + 1, p + 5));
-        const runtime = this.buffer[p + 5];
-        const commandType = this.buffer[p + 6];
-        this.position += 7;
-
-        const payload = new Array(numberOfElementsInPayload);
-        for (let i = 0; i < numberOfElementsInPayload; i++) {
-            payload[i] = this.readObject(this.buffer[this.position]);
-        }
-
-        return new Command(runtime, commandType, payload);
-    }
-
-    // old implementation
-    // readCommand() {
-    //     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
-    //     const command = new Command(runtime, type, [])
-    //     return this.readCommandRecursively(numberOfElementsInPayload, command)
-    // }
-    //
-    // readCommandRecursively(numberOfElementsInPayloadLeft, cmd) {
-    //     if (numberOfElementsInPayloadLeft === 0) return cmd
-    //     const p = this.position
-    //     cmd = cmd.addArgToPayload(this.readObject(this.buffer[p]))
-    //     return this.readCommandRecursively(numberOfElementsInPayloadLeft - 1, cmd)
-    // }
-
-    readString() {
-        let p = this.position
-        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() {
-        const size = 4
-        this.position += 2
-        const p = this.position
-        this.position += size
-        return TypeDeserializer.deserializeInt(this.buffer.slice(p, p + size))
-    }
-
-    readBool() {
-        const size = 1
-        this.position += 2
-        const p = this.position
-        this.position += size
-        return TypeDeserializer.deserializeBool(this.buffer.slice(p, p + size))
-    }
-
-    readFloat() {
-        const size = 4
-        this.position += 2
-        const p = this.position
-        this.position += size
-        return TypeDeserializer.deserializeFloat(this.buffer.slice(p, p + size))
-    }
-
-    readByte() {
-        const size = 1
-        this.position += 2
-        const p = this.position
-        this.position += size
-        return TypeDeserializer.deserializeByte(this.buffer.slice(p, p + size))
-    }
-
-    readChar() {
-        const size = 1
-        this.position += 2
-        const p = this.position
-        this.position += size
-        return TypeDeserializer.deserializeChar(this.buffer.slice(p, p + size))
-    }
-
-    readLongLong() {
-        const size = 8
-        this.position += 2
-        const p = this.position
-        this.position += size
-        return TypeDeserializer.deserializeLongLong(this.buffer.slice(p, p + size))
-    }
-
-    readDouble() {
-        const size = 8
-        this.position += 2
-        const p = this.position
-        this.position += size
-        return TypeDeserializer.deserializeDouble(this.buffer.slice(p, p + size))
-    }
-
-    readUllong() {
-        const size = 8
-        this.position += 2
-        const p = this.position
-        this.position += size
-        return TypeDeserializer.deserializeULLong(this.buffer.slice(p, p + size))
-    }
-
-    readUInt() {
-        const size = 4
-        this.position += 2
-        const p = this.position
-        this.position += size
-        return TypeDeserializer.deserializeUInt(this.buffer.slice(p, p + size))
-    }
-
-    readNull() {
-        const size = 1
-        this.position += 2
-        this.position += size
-        return TypeDeserializer.deserializeNull()
-    }
-}
-
-module.exports = CommandDeserializer

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/protocol/CommandSerializer.js

@@ -1,50 +0,0 @@
-
-const Command = require('../../utils/Command');
-const TypeSerializer = require('./TypeSerializer');
-const RuntimeName = require('../../utils/RuntimeName');
-
-class CommandSerializer {
-    serialize(rootCommand, connectionData) {
-        const buffers = [];
-        // Write runtime name and a zero byte for runtime version.
-        buffers.push(Uint8Array.of(rootCommand.runtimeName, 0));
-
-        if (connectionData) {
-            buffers.push(connectionData.serializeConnectionData());
-        } else {
-
-            buffers.push(Uint8Array.of(0, 0, 0, 0, 0, 0, 0));
-        }
-
-        buffers.push(Uint8Array.of(RuntimeName.Nodejs, rootCommand.commandType));
-
-        this.serializeRecursively(rootCommand, buffers);
-
-        return concatenateUint8Arrays(buffers);
-    }
-
-    serializeRecursively(command, buffers) {
-        for (const item of command.payload) {
-            if (item instanceof Command) {
-                buffers.push(TypeSerializer.serializeCommand(item));
-                this.serializeRecursively(item, buffers);
-            } else {
-                buffers.push(TypeSerializer.serializePrimitive(item));
-            }
-        }
-    }
-}
-
-function concatenateUint8Arrays(arrays) {
-    let totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
-    const result = new Uint8Array(totalLength);
-
-    let offset = 0;
-    for (const arr of arrays) {
-        result.set(arr, offset);
-        offset += arr.length;
-    }
-    return result;
-}
-
-module.exports = CommandSerializer;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/protocol/TypeDeserializer.js

@@ -1,83 +0,0 @@
-const Command = require('../../utils/Command')
-const StringEncodingMode = require('../../utils/StringEncodingMode')
-const { Buffer } = require('buffer')
-
-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: {
-                const 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)
-    }
-
-    // eslint-disable-next-line no-unused-vars
-    static deserializeNull(encodedNull = null) {
-        return null
-    }
-}
-
-module.exports = TypeDeserializer

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/protocol/TypeSerializer.js

@@ -1,143 +0,0 @@
-const Command = require('../../utils/Command')
-const Type = require('../../utils/Type')
-const StringEncodingMode = require('../../utils/StringEncodingMode')
-const { Buffer } = require('buffer')
-const CustomError = require('../../utils/CustomError')
-
-const encoder = new TextEncoder()
-
-class TypeSerializer {
-    static serializePrimitive(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) {
-            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) {
-            return TypeSerializer.serializeString(payload_item)
-        } else if (typeof payload_item === 'boolean' || payload_item instanceof Boolean) {
-            return TypeSerializer.serializeBool(payload_item)
-        } else {
-            if (payload_item instanceof Promise) {
-                throw new CustomError('Type not supported - Promise', JSON.stringify(payload_item))
-            }
-            if (payload_item === undefined) {
-                throw 'Type not supported - undefined'
-            }
-            throw 'Unknown type - not supported in JavaScript'
-        }
-    }
-
-    static serializeCommand(command) {
-        const buffer = Buffer.alloc(7)
-        buffer.writeUInt8(Type.JAVONET_COMMAND, 0)
-        buffer.fill(Buffer.from(this.serializeIntValue(command.payload.length)), 1, 5)
-        buffer.writeUInt8(command.runtime, 5)
-        buffer.writeUInt8(command.commandType, 6)
-        return buffer
-    }
-
-    static serializeString(string_value) {
-        let bytes = encoder.encode(string_value)
-        const buffer = Buffer.alloc(6 + bytes.length)
-        buffer.writeUInt8(Type.JAVONET_STRING, 0)
-        buffer.writeUInt8(StringEncodingMode.UTF8, 1)
-        buffer.fill(Buffer.from(this.serializeIntValue(bytes.length)), 2, 6)
-        buffer.fill(Buffer.from(bytes), 6, 6 + bytes.length)
-        return buffer
-    }
-
-    static serializeInt(int_value) {
-        const buffer = Buffer.alloc(6)
-        buffer.writeUInt8(Type.JAVONET_INTEGER, 0)
-        buffer.writeUInt8(4, 1)
-        buffer.writeInt32LE(int_value, 2)
-        return buffer
-    }
-
-    static serializeBool(bool_value) {
-        const buffer = Buffer.alloc(3)
-        buffer.writeUInt8(Type.JAVONET_BOOLEAN, 0)
-        buffer.writeUInt8(1, 1)
-        buffer.writeUInt8(bool_value ? 1 : 0, 2)
-        return buffer
-    }
-
-    static serializeFloat(float_value) {
-        const buffer = Buffer.alloc(6)
-        buffer.writeUInt8(Type.JAVONET_FLOAT, 0)
-        buffer.writeUInt8(4, 1)
-        buffer.writeFloatLE(float_value, 2)
-        return buffer
-    }
-
-    static serializeByte(byte_value) {
-        const buffer = Buffer.alloc(3)
-        buffer.writeUInt8(Type.JAVONET_BYTE, 0)
-        buffer.writeUInt8(1, 1)
-        buffer.writeUInt8(byte_value, 2)
-        return buffer
-    }
-
-    static serializeChar(char_value) {
-        const buffer = Buffer.alloc(3)
-        buffer.writeUInt8(Type.JAVONET_CHAR, 0)
-        buffer.writeUInt8(1, 1)
-        buffer.writeUInt8(char_value, 2)
-        return buffer
-    }
-
-    static serializeLongLong(longlong_value) {
-        const buffer = Buffer.alloc(10)
-        buffer.writeUInt8(Type.JAVONET_LONG_LONG, 0)
-        buffer.writeUInt8(8, 1)
-        buffer.writeBigInt64LE(BigInt(longlong_value), 2)
-        return buffer
-    }
-
-    static serializeDouble(double_value) {
-        const buffer = Buffer.alloc(10)
-        buffer.writeUInt8(Type.JAVONET_DOUBLE, 0)
-        buffer.writeUInt8(8, 1)
-        buffer.writeDoubleLE(double_value, 2)
-        return buffer
-    }
-
-    static serializeULLong(ullong_value) {
-        const buffer = Buffer.alloc(10)
-        buffer.writeUInt8(Type.JAVONET_UNSIGNED_LONG_LONG, 0)
-        buffer.writeUInt8(8, 1)
-        buffer.writeBigUInt64LE(ullong_value, 2)
-        return buffer
-    }
-
-    static serializeUInt(uint_value) {
-        const buffer = Buffer.alloc(6)
-        buffer.writeUInt8(Type.JAVONET_UNSIGNED_INTEGER, 0)
-        buffer.writeUInt8(4, 1)
-        buffer.writeUInt32LE(uint_value, 2)
-        return buffer
-    }
-
-    static serializeNull() {
-        const buffer = Buffer.alloc(3)
-        buffer.writeUInt8(Type.JAVONET_NULL, 0)
-        buffer.writeUInt8(1, 1)
-        buffer.writeUInt8(0, 2)
-        return buffer
-    }
-
-    static serializeIntValue(int_value) {
-        const buffer = Buffer.alloc(4)
-        buffer.writeInt32LE(int_value, 0)
-        return buffer
-    }
-}
-
-module.exports = TypeSerializer

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/receiver/Receiver.js

@@ -1,32 +0,0 @@
-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

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/receiver/ReceiverNative.js

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

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/referenceCache/ReferencesCache.js

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

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/transmitter/Transmitter.js

@@ -1,21 +0,0 @@
-const wrapper = require('./TransmitterWrapper')
-
-class Transmitter {
-    static sendCommand(messageArray) {
-        return wrapper.sendCommand(messageArray)
-    }
-
-    static activate = function (licenseKey) {
-        return wrapper.activate(licenseKey)
-    }
-
-    static setConfigSource(configSource) {
-        return wrapper.setConfigSource(configSource)
-    }
-
-    static setJavonetWorkingDirectory(workingDirectory) {
-        return wrapper.setJavonetWorkingDirectory(workingDirectory)
-    }
-}
-
-module.exports = Transmitter

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/transmitter/TransmitterWebsocket.js

@@ -1,33 +0,0 @@
-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

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/transmitter/TransmitterWrapper.js

@@ -1,47 +0,0 @@
-let library
-
-class TransmitterWrapper {
-
-    static isNativeLibraryLoaded() {
-        return library !== undefined
-    }
-
-    static loadNativeLibrary() {
-        if (this.isNativeLibraryLoaded()) {
-            return
-        }
-
-        let binariesRootPath = String(`${require('path').resolve(__dirname, '../../../../')}`)
-
-        const nativeAddonPath = `${binariesRootPath}/build/Release/JavonetNodejsRuntimeAddon.node`
-
-        library = require(nativeAddonPath)
-
-        library.initializeTransmitter(binariesRootPath)
-        // eslint-disable-next-line no-unused-vars
-        const ReceiverNative = require('../receiver/ReceiverNative')
-        library.setReceiverNative(global.ReceiverNative)
-    }
-
-    static activate(licenseKey) {
-        this.loadNativeLibrary()
-        return library.activate(licenseKey)
-    }
-
-    static sendCommand(messageArray) {
-        this.loadNativeLibrary()
-        return library.sendCommand(messageArray)
-    }
-
-    static setConfigSource(configSource) {
-        this.loadNativeLibrary()
-        return library.setConfigSource(configSource)
-    }
-
-    static setJavonetWorkingDirectory(path) {
-        this.loadNativeLibrary()
-        library.setJavonetWorkingDirectory(path)
-    }
-}
-
-module.exports = TransmitterWrapper

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/typeCache/TypeCache.js

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