javonet-ruby-sdk 2.5.15 → 2.5.16

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/SetStaticFieldHandler.d.ts

@@ -0,0 +1,5 @@
+export class SetStaticFieldHandler extends AbstractHandler {
+    requiredParametersCount: number;
+    process(command: any): number;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/handler/ValueHandler.d.ts

@@ -0,0 +1,4 @@
+export class ValueHandler extends AbstractHandler {
+    process(command: any): any;
+}
+import { AbstractHandler } from './AbstractHandler.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/interpreter/Interpreter.d.ts

@@ -0,0 +1,27 @@
+export class Interpreter {
+    handler: any;
+    /**
+     *
+     * @param {Command} command
+     * @param {IConnectionData} connectionData
+     * @returns
+     */
+    executeAsync(command: Command, connectionData: IConnectionData): Promise<import("../../utils/Command.js").Command>;
+    /**
+     *
+     * @param {Command} command
+     * @param {WsConnectionData} connectionData
+     * @returns {Promise<Command>}
+     */
+    execute(command: Command, connectionData: WsConnectionData): Promise<Command>;
+    /**
+     *
+     * @param {number[]} messageByteArray
+     * @returns {Command}
+     */
+    process(messageByteArray: number[]): Command;
+}
+export type Receiver = import("../receiver/Receiver.js").Receiver;
+export type Transmitter = import("../transmitter/Transmitter.js").Transmitter;
+export type TransmitterWebsocket = import("../transmitter/TransmitterWebsocket.js").TransmitterWebsocket;
+export type TransmitterWebsocketBrowser = import("../transmitter/TransmitterWebsocketBrowser.js").TransmitterWebsocketBrowser;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/namespaceCache/NamespaceCache.d.ts

@@ -0,0 +1,9 @@
+export class NamespaceCache {
+    static _instance: null;
+    namespaceCache: any[];
+    cacheNamespace(namespaceRegex: any): void;
+    isNamespaceCacheEmpty(): boolean;
+    isTypeAllowed(typeToCheck: any): boolean;
+    getCachedNamespaces(): any[];
+    clearCache(): number;
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/protocol/CommandDeserializer.d.ts

@@ -0,0 +1,25 @@
+export class CommandDeserializer {
+    constructor(buffer: any);
+    buffer: any;
+    command: Command;
+    position: number;
+    /**
+     * @returns {Command}
+     */
+    deserialize(): Command;
+    isAtEnd(): boolean;
+    readObject(typeNum: any): string | number | bigint | boolean | Command | (() => bigint) | null;
+    readCommand(): Command;
+    readString(): string;
+    readInt(): number;
+    readBool(): boolean;
+    readFloat(): number;
+    readByte(): number;
+    readChar(): number;
+    readLongLong(): bigint;
+    readDouble(): number;
+    readUllong(): bigint;
+    readUInt(): number;
+    readNull(): null;
+}
+import { Command } from '../../utils/Command.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/protocol/CommandSerializer.d.ts

@@ -0,0 +1,4 @@
+export class CommandSerializer {
+    serialize(rootCommand: any, connectionData: any): Uint8Array<any>;
+    serializeRecursively(command: any, buffers: any): void;
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/protocol/TypeDeserializer.d.ts

@@ -0,0 +1,15 @@
+export class TypeDeserializer {
+    static deserializeCommand(encodedCommand: any): Command;
+    static deserializeString(stringEncodingMode: any, encodedString: any): string;
+    static deserializeInt(encodedInt: any): number;
+    static deserializeBool(encodedBool: any): boolean;
+    static deserializeFloat(encodedFloat: any): number;
+    static deserializeByte(encodedByte: any): number;
+    static deserializeChar(encodedChar: any): number;
+    static deserializeLongLong(encodedLongLong: any): bigint;
+    static deserializeDouble(encodedDouble: any): number;
+    static deserializeULLong(encodedULLong: any): bigint;
+    static deserializeUInt(encodedUInt: any): number;
+    static deserializeNull(encodedNull?: null): null;
+}
+import { Command } from '../../utils/Command.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/protocol/TypeSerializer.d.ts

@@ -0,0 +1,17 @@
+export class TypeSerializer {
+    static serializePrimitive(payload_item: any): Buffer<ArrayBuffer>;
+    static serializeCommand(command: any): Buffer<ArrayBuffer>;
+    static serializeString(string_value: any): Buffer<ArrayBuffer>;
+    static serializeInt(int_value: any): Buffer<ArrayBuffer>;
+    static serializeBool(bool_value: any): Buffer<ArrayBuffer>;
+    static serializeFloat(float_value: any): Buffer<ArrayBuffer>;
+    static serializeByte(byte_value: any): Buffer<ArrayBuffer>;
+    static serializeChar(char_value: any): Buffer<ArrayBuffer>;
+    static serializeLongLong(longlong_value: any): Buffer<ArrayBuffer>;
+    static serializeDouble(double_value: any): Buffer<ArrayBuffer>;
+    static serializeULLong(ullong_value: any): Buffer<ArrayBuffer>;
+    static serializeUInt(uint_value: any): Buffer<ArrayBuffer>;
+    static serializeNull(): Buffer<ArrayBuffer>;
+    static serializeIntValue(int_value: any): Buffer<ArrayBuffer>;
+}
+import { Buffer } from 'buffer';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/receiver/Receiver.d.ts

@@ -0,0 +1,14 @@
+export class Receiver {
+    static connectionData: InMemoryConnectionData;
+    /**
+     * @param {number[]} messageByteArray
+     */
+    static sendCommand(messageByteArray: number[]): Uint8Array<any>;
+    /**
+     * @param {Int8Array} messageByteArray
+     * @returns {Int8Array}
+     */
+    static heartBeat(messageByteArray: Int8Array): Int8Array;
+    Receiver(): void;
+}
+import { InMemoryConnectionData } from '../../utils/connectionData/InMemoryConnectionData.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/receiver/ReceiverNative.d.ts

@@ -0,0 +1,4 @@
+export class ReceiverNative {
+    static sendCommand(messageByteArray: any): Uint8Array<any>;
+    static heartBeat(messageByteArray: any): Int8Array<ArrayBufferLike>;
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/referenceCache/ReferencesCache.d.ts

@@ -0,0 +1,24 @@
+export type Cache = {
+    [x: string]: any;
+};
+export class ReferencesCache {
+    /**
+     * @returns {ReferencesCache}
+     */
+    static getInstance(): ReferencesCache;
+    /**
+     * @param {any} reference
+     * @returns {string}
+     */
+    cacheReference(reference: any): string;
+    /**
+     * @param {string} id
+     * @returns {any}
+     */
+    resolveReference(id: string): any;
+    /**
+     * @param {string} id
+     * @returns {number}
+     */
+    deleteReference(id: string): number;
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/transmitter/Transmitter.d.ts

@@ -0,0 +1,6 @@
+export class Transmitter {
+    static sendCommand(messageArray: any): any;
+    static activate: (licenseKey: any) => any;
+    static setConfigSource(configSource: any): any;
+    static setJavonetWorkingDirectory(workingDirectory: any): void;
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/transmitter/TransmitterWebsocket.d.ts

@@ -0,0 +1,21 @@
+export class TransmitterWebsocket {
+    /**
+     * @returns {void}
+     */
+    static initialize(): void;
+    /**
+     * @returns {void}
+     */
+    static setConfigSource(): void;
+    /**
+     * @returns {void}
+     */
+    static activate(): void;
+    /**
+     * @async
+     * @param {number[]} messageByteArray
+     * @param {WsConnectionData} connectionData
+     * @returns {Promise<number[]>} responseByteArray
+     */
+    static sendCommand(messageByteArray: number[], connectionData: WsConnectionData): Promise<number[]>;
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/transmitter/TransmitterWebsocketBrowser.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @typedef {object} ConnectionData
+ * @property {string} hostname
+ */
+export class TransmitterWebsocketBrowser {
+    /**
+     * @returns {void}
+     */
+    static initialize(): void;
+    /**
+     * @returns {void}
+     */
+    static activate(): void;
+    /**
+     * @async
+     * @param {Int8Array} messageByteArray
+     * @param {ConnectionData} connectionData
+     * @returns {Promise<Int8Array>} responseByteArray
+     */
+    static sendCommand(messageByteArray: Int8Array, connectionData: ConnectionData): Promise<Int8Array>;
+    /**
+     * @async
+     * @param {any} configSource
+     * @returns {void}
+     */
+    static setConfigSource(configSource: any): void;
+}
+export type ConnectionData = {
+    hostname: string;
+};

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/transmitter/TransmitterWrapper.d.ts

@@ -0,0 +1,11 @@
+export class TransmitterWrapper {
+    static isNativeLibraryLoaded(): boolean;
+    static loadNativeLibrary(): void;
+    /**
+     * @param {string} licenseKey
+     */
+    static activate(licenseKey: string): any;
+    static sendCommand(messageArray: any): any;
+    static setConfigSource(configSource: any): any;
+    static setJavonetWorkingDirectory(path: any): void;
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/typeCache/TypeCache.d.ts

@@ -0,0 +1,9 @@
+export class TypeCache {
+    static _instance: null;
+    typeCache: any[];
+    cacheType(typRegex: any): void;
+    isTypeCacheEmpty(): boolean;
+    isTypeAllowed(typeToCheck: any): boolean;
+    getCachedTypes(): any[];
+    clearCache(): number;
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/webSocketClient/WebSocketClient.d.ts

@@ -0,0 +1,50 @@
+/**
+ * WebSocketClient class that handles WebSocket connection, message sending, and automatic disconnection.
+ */
+export class WebSocketClient {
+    /**
+     * @param {string} url
+     * @param {object} options
+     */
+    constructor(url: string, options: object);
+    /**
+     * @type {string}
+     */
+    url: string;
+    /**
+     * @type {WebSocket | null}
+     */
+    instance: WebSocket | null;
+    /**
+     * @type {boolean} isConnected indicates whether the WebSocket is connected.
+     */
+    isConnected: boolean;
+    /**
+     * @type {boolean}
+     */
+    isDisconnectedAfterMessage: boolean;
+    /**
+     * Connects to the WebSocket server.
+     * @async
+     * @returns {Promise<WebSocket>} - A promise that resolves when the connection is established.
+     */
+    connect(): Promise<WebSocket>;
+    /**
+     * Sends messageArray through websocket connection
+     * @async
+     * @param {Buffer|ArrayBuffer|Buffer[]} messageArray
+     * @returns {Promise<Buffer|ArrayBuffer|Buffer[]>}
+     */
+    send(messageArray: Buffer | ArrayBuffer | Buffer[]): Promise<Buffer | ArrayBuffer | Buffer[]>;
+    /**
+     * Disconnects the WebSocket by terminating the connection.
+     */
+    disconnect(): void;
+    /**
+     * Connects to the WebSocket server.
+     * @private
+     * @async
+     * @returns {Promise<WebSocket>} - A promise that resolves when the connection is established.
+     */
+    private _connect;
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/core/webSocketClient/WebSocketClientBrowser.d.ts

@@ -0,0 +1,63 @@
+export type Options = {
+    isDisconnectedAfterMessage: boolean;
+};
+/**
+ * @typedef {object} Options
+ * @property {boolean} isDisconnectedAfterMessage
+ */
+/**
+ * WebSocketClient class that handles WebSocket connection, message sending, and automatic disconnection.
+ */
+export class WebSocketClientBrowser {
+    /**
+     * @param {string} url
+     * @param {Options} [options]
+     */
+    constructor(url: string, options?: Options);
+    /**
+     * @type {string}
+     */
+    url: string;
+    /**
+     * @type {WebSocket | null}
+     */
+    instance: WebSocket | null;
+    /**
+     * @type {boolean} isConnected indicates whether the WebSocket is connected.
+     */
+    isConnected: boolean;
+    /**
+     * @type {boolean}
+     */
+    isDisconnectedAfterMessage: boolean;
+    /**
+     * Sends messageArray through websocket connection
+     * @async
+     * @param {Int8Array} messageArray
+     * @returns {Promise<Int8Array>}
+     */
+    send(messageArray: Int8Array): Promise<Int8Array>;
+    /**
+     * Disconnects the WebSocket by terminating the connection.
+     * @returns {void}
+     *
+     */
+    disconnect(): void;
+    /**
+     * Connects to the WebSocket server.
+     * @private
+     * @async
+     * @returns {Promise<void>} - A promise that resolves when the connection is established.
+     */
+    private _connect;
+    /**
+     * Sends the data to the WebSocket server and listens for a response.
+     * @private
+     * @async
+     * @param {Int8Array} data - The data to send.
+     * @param {Function} resolve - The resolve function for the Promise.
+     * @param {Function} reject - The reject function for the Promise.
+     * @returns {void}
+     */
+    private _sendMessage;
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{lib/sdk/ConfigRuntimeFactory.js → dist/types/sdk/ConfigRuntimeFactory.d.ts}

@@ -1,155 +1,73 @@
-const JsonFileResolver = require('./tools/JsonFileResolver')
-const Transmitter = require('../core/transmitter/Transmitter')
-
-const {
-    RuntimeName,
-    RuntimeNameHandler,
-    InMemoryConnectionData,
-    WsConnectionData,
-    RuntimeContext,
-} = require('../..')
-const TcpConnectionData = require('../utils/connectionData/TcpConnectionData')
-
 /**
  * The ConfigRuntimeFactory class provides methods for creating runtime contexts.
  * Each method corresponds to a specific runtime (CLR, JVM, .NET Core, Perl, Ruby, Node.js, Python) and returns a RuntimeContext instance for that runtime.
  * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
  */
-class ConfigRuntimeFactory {
-    constructor(path) {
-        this.path = path
-        Transmitter.setConfigSource(path)
-    }
-
+export class ConfigRuntimeFactory {
+    /**
+     * @param {object | string} configSource
+     * @param {import('../core/transmitter/Transmitter.js') | null} transmitter
+     */
+    constructor(configSource: object | string, transmitter?: typeof import("../core/transmitter/Transmitter.js") | null);
+    /** @type {import('../core/transmitter/Transmitter.js') | null} */
+    transmitter: typeof import("../core/transmitter/Transmitter.js") | null;
+    configSource: string | object;
     /**
      * Creates RuntimeContext instance to interact with the .NET Framework runtime.
      * @param {string} [configName="default"] - The name of the configuration to use (optional).
      * @return {RuntimeContext} a RuntimeContext instance for the .NET Framework runtime
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
      */
-    clr(configName = 'default') {
-        return this.#getRuntimeContext(RuntimeName.Clr, configName)
-    }
-
+    clr(configName?: string): RuntimeContext;
     /**
      * Creates RuntimeContext instance to interact with the JVM runtime.
      * @param {string} [configName="default"] - The name of the configuration to use (optional).
      * @return {RuntimeContext} a RuntimeContext instance for the JVM runtime
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
      */
-    jvm(configName = 'default') {
-        return this.#getRuntimeContext(RuntimeName.Jvm, configName)
-    }
-
+    jvm(configName?: string): RuntimeContext;
     /**
      * Creates RuntimeContext instance to interact with the .NET runtime.
      * @param {string} [configName="default"] - The name of the configuration to use (optional).
      * @return {RuntimeContext} a RuntimeContext instance for the .NET runtime
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
      */
-    netcore(configName = 'default') {
-        return this.#getRuntimeContext(RuntimeName.Netcore, configName)
-    }
-
+    netcore(configName?: string): RuntimeContext;
     /**
      * Creates RuntimeContext instance to interact with the Perl runtime.
      * @param {string} [configName="default"] - The name of the configuration to use (optional).
      * @return {RuntimeContext} a RuntimeContext instance for the Perl runtime
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
      */
-    perl(configName = 'default') {
-        return this.#getRuntimeContext(RuntimeName.Perl, configName)
-    }
-
+    perl(configName?: string): RuntimeContext;
     /**
      * Creates RuntimeContext instance to interact with the Python runtime.
      * @param {string} [configName="default"] - The name of the configuration to use (optional).
      * @return {RuntimeContext} a RuntimeContext instance for the Python runtime
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
      */
-    python(configName = 'default') {
-        return this.#getRuntimeContext(RuntimeName.Python, configName)
-    }
-
+    python(configName?: string): RuntimeContext;
     /**
      * Creates RuntimeContext instance to interact with the Ruby runtime.
      * @param {string} [configName="default"] - The name of the configuration to use (optional).
      * @return {RuntimeContext} a RuntimeContext instance for the Ruby runtime
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
      */
-    ruby(configName = 'default') {
-        return this.#getRuntimeContext(RuntimeName.Ruby, configName)
-    }
-
+    ruby(configName?: string): RuntimeContext;
     /**
      * Creates RuntimeContext instance to interact with Node.js runtime.
      * @param {string} [configName="default"] - The name of the configuration to use (optional).
      * @return {RuntimeContext} a RuntimeContext instance for the Node.js runtime
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
      */
-    nodejs(configName = 'default') {
-        return this.#getRuntimeContext(RuntimeName.Nodejs, configName)
-    }
-
+    nodejs(configName?: string): RuntimeContext;
     /**
      * Creates RuntimeContext instance to interact with the Python 2.7 runtime.
      * @param {string} [configName="default"] - The name of the configuration to use (optional).
      * @return {RuntimeContext} a RuntimeContext instance for the Python 2.7 runtime
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
      */
-    python27(configName = 'default') {
-        return this.#getRuntimeContext(RuntimeName.Python27, configName)
-    }
-
-    #getRuntimeContext(runtime, configName = 'default') {
-        let jfr = new JsonFileResolver(this.path)
-
-        try {
-            let licenseKey = jfr.getLicenseKey()
-            Transmitter.activateWithCredentials(licenseKey)
-            // eslint-disable-next-line no-unused-vars
-        } catch (error) {
-            // licenseKey not found - do nothing
-        }
-        let rtmCtx = null
-        let connData = null
-        let connType = jfr.getChannelType(RuntimeNameHandler.getName(runtime), configName)
-        if (connType === 'inMemory') {
-            connData = new InMemoryConnectionData()
-        } else if (connType === 'tcp') {
-            connData = new TcpConnectionData(
-                jfr.getChannelHost(RuntimeNameHandler.getName(runtime), configName),
-                jfr.getChannelPort(RuntimeNameHandler.getName(runtime), configName)
-            )
-        } else if (connType === 'webSocket') {
-            connData = new WsConnectionData(
-                jfr.getChannelHost(RuntimeNameHandler.getName(runtime), configName)
-            )
-        } else {
-            throw new Error('Unsupported connection type: ' + connType)
-        }
-
-        rtmCtx = RuntimeContext.getInstance(runtime, connData)
-        this.#loadModules(runtime, configName, jfr, rtmCtx)
-        return rtmCtx
-    }
-
-    #loadModules(runtime, configName, jfr, rtmCtx) {
-        const modules = jfr
-            .getModules(RuntimeNameHandler.getName(runtime), configName)
-            .split(',')
-            .filter((module) => module.trim() !== '')
-
-        const configDirectoryAbsolutePath = require('path').dirname(this.path)
-
-        modules.forEach((module) => {
-            if (require('path').isAbsolute(module)) {
-                rtmCtx.loadLibrary(module)
-            } else {
-                rtmCtx.loadLibrary(require('path').join(configDirectoryAbsolutePath, module))
-            }
-        })
-    }
+    python27(configName?: string): RuntimeContext;
+    #private;
 }
-
-module.exports = ConfigRuntimeFactory
+import { RuntimeContext } from './RuntimeContext.js';