javonet-ruby-sdk 2.5.15 → 2.5.16

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

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/webSocketClient/WebSocketClient.js

@@ -1,136 +0,0 @@
-const WebSocket = require('ws')
-
-/**
- * Enum for WebSocket states.
- * @readonly
- * @enum {string}
- */
-const WebSocketStateEnum = {
-    OPEN: 'open',
-    CLOSE: 'close',
-    ERROR: 'error',
-}
-
-/**
- * WebSocketClient class that handles WebSocket connection, message sending, and automatic disconnection.
- */
-class WebSocketClient {
-    /**
-     * @param {string} url
-     * @param {object} options
-     */
-    constructor(url, options) {
-        /**
-         * @type {string}
-         */
-        this.url = url
-
-        /**
-         * @type {WebSocket | null}
-         */
-        this.instance = null
-
-        /**
-         * @type {boolean} isConnected indicates whether the WebSocket is connected.
-         */
-        this.isConnected = false
-
-        /**
-         * @type {boolean}
-         */
-        this.isDisconnectedAfterMessage = options?.isDisconnectedAfterMessage ?? true
-    }
-
-    /**
-     * Connects to the WebSocket server.
-     * @async
-     * @returns {Promise<WebSocket>} - A promise that resolves when the connection is established.
-     */
-    connect() {
-        return new Promise((resolve, reject) => {
-            const client = new WebSocket(this.url)
-
-            client.on(WebSocketStateEnum.OPEN, () => {
-                this.instance = client;
-                resolve(client);
-            })
-
-            // eslint-disable-next-line no-unused-vars
-            client.on(WebSocketStateEnum.ERROR, (error) => {
-                reject(error)
-            })
-
-            client.on(WebSocketStateEnum.CLOSE, () => {
-                reject(new Error("Connection closed before receiving message"))
-            })
-        });
-    }
-
-    /**
-     * Sends messageArray through websocket connection
-     * @async
-     * @param {Buffer|ArrayBuffer|Buffer[]} messageArray
-     * @returns {Promise<Buffer|ArrayBuffer|Buffer[]>}
-     */
-    send(messageArray) {
-        return new Promise((resolve, reject) => {
-            (this.instance ? Promise.resolve(this.instance) : this._connect()).then((client) => {
-                client.send(messageArray, (err) => {
-                    if (err) {
-                        reject(err)
-                    }
-                })
-
-                client.on('message', (message) => {
-                    resolve(message)
-
-                    if (this.isDisconnectedAfterMessage) {
-                        this.disconnect()
-                    }
-                })
-            }).catch((error) => {
-                reject(error)
-            })
-        })
-    }
-
-    /**
-     * Disconnects the WebSocket by terminating the connection.
-     */
-    disconnect() {
-        if (this.instance) {
-            this.instance.close()
-            this.instance = null
-        }
-        this.isConnected = false
-    }
-
-    /**
-     * Connects to the WebSocket server.
-     * @private
-     * @async
-     * @returns {Promise<WebSocket>} - A promise that resolves when the connection is established.
-     */
-    _connect() {
-        return new Promise((resolve, reject) => {
-            const client = new WebSocket(this.url)
-
-            client.on(WebSocketStateEnum.OPEN, () => {
-                this.isConnected = true
-                this.instance = client;
-                resolve(client)
-            })
-
-            // eslint-disable-next-line no-unused-vars
-            client.on(WebSocketStateEnum.ERROR, (error) => {
-                reject(error)
-            })
-
-            client.on(WebSocketStateEnum.CLOSE, () => {
-                reject(new Error("Connection closed before receiving message"))
-            })
-        })
-    }
-}
-
-module.exports = WebSocketClient

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/declarations.d.ts

@@ -1,64 +0,0 @@
-/**
- * Represents WebSocket connection data.
- */
-export class WsConnectionData {
-    /**
-     * Constructs a new WsConnectionData instance.
-     * @param hostname - The hostname of the connection.
-     */
-    constructor(hostname: string)
-
-    readonly connectionType: any
-
-    /** The hostname of the connection. */
-    hostname: any
-
-    /**
-     * Serializes the connection data.
-     * @returns An array of connection data values.
-     */
-    serializeConnectionData(): number[]
-
-    /**
-     * Checks equality with another WsConnectionData object.
-     * @param other - The object to compare with.
-     * @returns `true` if equal, otherwise `false`.
-     */
-    equals(other: any): boolean
-}
-
-declare enum RuntimeName {
-    Clr = 0,
-    Go = 1,
-    Jvm = 2,
-    Netcore = 3,
-    Perl = 4,
-    Python = 5,
-    Ruby = 6,
-    Nodejs = 7,
-    Cpp = 8,
-}
-
-interface RuntimeChannel {
-    type: 'inMemory' | 'tcp' | 'webSocket'
-    host?: string
-    port?: number
-}
-
-interface Runtime {
-    name: string
-    customOptions: string
-    modules: string
-    channel: RuntimeChannel
-    runtimeName: RuntimeName
-}
-
-type Runtimes = {
-    [Key in keyof typeof RuntimeName]: Runtime[]
-}
-
-export interface ConfigSource {
-    [key: string]: any
-    licenseKey: string
-    runtimes: Partial<Runtimes>
-}