javonet-ruby-sdk 2.5.15 → 2.5.17

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

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Transmitter_exports = {};
+__export(Transmitter_exports, {
+  Transmitter: () => Transmitter
+});
+module.exports = __toCommonJS(Transmitter_exports);
+var import_TransmitterWrapper = require("./TransmitterWrapper.cjs");
+class Transmitter {
+  static sendCommand(messageArray) {
+    return import_TransmitterWrapper.TransmitterWrapper.sendCommand(messageArray);
+  }
+  static activate = function(licenseKey) {
+    return import_TransmitterWrapper.TransmitterWrapper.activate(licenseKey);
+  };
+  static setConfigSource(configSource) {
+    return import_TransmitterWrapper.TransmitterWrapper.setConfigSource(configSource);
+  }
+  static setJavonetWorkingDirectory(workingDirectory) {
+    return import_TransmitterWrapper.TransmitterWrapper.setJavonetWorkingDirectory(workingDirectory);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Transmitter
+});

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

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TransmitterWebsocket_exports = {};
+__export(TransmitterWebsocket_exports, {
+  TransmitterWebsocket: () => TransmitterWebsocket
+});
+module.exports = __toCommonJS(TransmitterWebsocket_exports);
+var import_WebSocketClient = require("../webSocketClient/WebSocketClient.cjs");
+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 import_WebSocketClient.WebSocketClient(hostname).send(messageByteArray);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TransmitterWebsocket
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/transmitter/TransmitterWebsocketBrowser.cjs

@@ -0,0 +1,59 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TransmitterWebsocketBrowser_exports = {};
+__export(TransmitterWebsocketBrowser_exports, {
+  TransmitterWebsocketBrowser: () => TransmitterWebsocketBrowser
+});
+module.exports = __toCommonJS(TransmitterWebsocketBrowser_exports);
+var import_WebSocketClientBrowser = require("../webSocketClient/WebSocketClientBrowser.cjs");
+class TransmitterWebsocketBrowser {
+  /**
+   * @returns {void}
+   */
+  static initialize() {
+  }
+  /**
+   * @returns {void}
+   */
+  static activate() {
+  }
+  /**
+   * @async
+   * @param {Int8Array} messageByteArray
+   * @param {ConnectionData} connectionData
+   * @returns {Promise<Int8Array>} responseByteArray
+   */
+  static async sendCommand(messageByteArray, connectionData) {
+    const { hostname } = connectionData;
+    const response = new import_WebSocketClientBrowser.WebSocketClientBrowser(hostname).send(messageByteArray);
+    return response;
+  }
+  /**
+   * @async
+   * @param {any} configSource
+   * @returns {void}
+   */
+  // eslint-disable-next-line no-unused-vars
+  static setConfigSource(configSource) {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TransmitterWebsocketBrowser
+});

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

@@ -0,0 +1,75 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TransmitterWrapper_exports = {};
+__export(TransmitterWrapper_exports, {
+  TransmitterWrapper: () => TransmitterWrapper
+});
+module.exports = __toCommonJS(TransmitterWrapper_exports);
+var import_Runtime = require("../../utils/Runtime.cjs");
+var import_ReceiverNative = require("../receiver/ReceiverNative.cjs");
+const import_meta = {};
+let library;
+const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
+class TransmitterWrapper {
+  static isNativeLibraryLoaded() {
+    return library !== void 0;
+  }
+  static loadNativeLibrary() {
+    if (!(0, import_Runtime.isNodejsRuntime)()) {
+      throw new Error("Javonet.loadNativeLibrary is not supported in this runtime");
+    }
+    if (this.isNativeLibraryLoaded()) {
+      return;
+    }
+    try {
+      const path = requireDynamic("path");
+      const packagePath = (0, import_Runtime.getDependency)("javonet-binaries", import_meta.url);
+      const binariesRootPath = path.dirname(packagePath);
+      const nativeAddonPath = path.join(binariesRootPath, "build", "Release", "JavonetNodejsRuntimeAddon.node");
+      library = requireDynamic(nativeAddonPath);
+      library.initializeTransmitter(binariesRootPath);
+      library.setReceiverNative(global.ReceiverNative);
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * @param {string} licenseKey 
+   */
+  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);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TransmitterWrapper
+});

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

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TypeCache_exports = {};
+__export(TypeCache_exports, {
+  TypeCache: () => TypeCache
+});
+module.exports = __toCommonJS(TypeCache_exports);
+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;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TypeCache
+});

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

@@ -0,0 +1,150 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var WebSocketClient_exports = {};
+__export(WebSocketClient_exports, {
+  WebSocketClient: () => WebSocketClient
+});
+module.exports = __toCommonJS(WebSocketClient_exports);
+var import_Runtime = require("../../utils/Runtime.cjs");
+const import_meta = {};
+const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
+const WebSocketStateEnum = {
+  OPEN: "open",
+  CLOSE: "close",
+  ERROR: "error"
+};
+let WebSocket = null;
+class WebSocketClient {
+  /**
+   * @param {string} url
+   * @param {object} options
+   */
+  constructor(url, options) {
+    this.url = url;
+    this.instance = null;
+    this.isConnected = false;
+    this.isDisconnectedAfterMessage = options?.isDisconnectedAfterMessage ?? true;
+  }
+  /**
+   * Connects to the WebSocket server.
+   * @async
+   * @returns {Promise<WebSocket>} - A promise that resolves when the connection is established.
+   */
+  async connect() {
+    if (!WebSocket) {
+      if ((0, import_Runtime.isNodejsRuntime)()) {
+        try {
+          WebSocket = requireDynamic("ws");
+        } catch (error) {
+          if (error.code === "MODULE_NOT_FOUND") {
+            throw new Error("ws module not found. Please install it using npm install ws");
+          }
+          throw error;
+        }
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const client = new WebSocket(this.url);
+      client.on(WebSocketStateEnum.OPEN, () => {
+        this.instance = client;
+        resolve(client);
+      });
+      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() {
+    if (!WebSocket) {
+      if ((0, import_Runtime.isNodejsRuntime)()) {
+        try {
+          WebSocket = requireDynamic("ws");
+        } catch (error) {
+          if (error.code === "MODULE_NOT_FOUND") {
+            throw new Error("ws module not found. Please install it using npm install ws");
+          }
+          throw error;
+        }
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const client = new WebSocket(this.url);
+      client.on(WebSocketStateEnum.OPEN, () => {
+        this.isConnected = true;
+        this.instance = client;
+        resolve(client);
+      });
+      client.on(WebSocketStateEnum.ERROR, (error) => {
+        reject(error);
+      });
+      client.on(WebSocketStateEnum.CLOSE, () => {
+        reject(new Error("Connection closed before receiving message"));
+      });
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WebSocketClient
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/webSocketClient/WebSocketClientBrowser.cjs

@@ -0,0 +1,153 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var WebSocketClientBrowser_exports = {};
+__export(WebSocketClientBrowser_exports, {
+  WebSocketClientBrowser: () => WebSocketClientBrowser
+});
+module.exports = __toCommonJS(WebSocketClientBrowser_exports);
+var import_Runtime = require("../../utils/Runtime.cjs");
+const WebSocketState = (
+  /** @type {const} */
+  {
+    OPEN: "open",
+    CLOSE: "close",
+    ERROR: "error",
+    MESSAGE: "message"
+  }
+);
+let WsClient = null;
+if ((0, import_Runtime.isBrowserRuntime)()) {
+  WsClient = WebSocket;
+}
+class WebSocketClientBrowser {
+  /**
+   * @param {string} url
+   * @param {Options} [options]
+   */
+  constructor(url, options) {
+    this.url = url;
+    this.instance = null;
+    this.isConnected = false;
+    this.isDisconnectedAfterMessage = options?.isDisconnectedAfterMessage ?? false;
+  }
+  /**
+   * Sends messageArray through websocket connection
+   * @async
+   * @param {Int8Array} messageArray
+   * @returns {Promise<Int8Array>}
+   */
+  send(messageArray) {
+    return new Promise((resolve, reject) => {
+      try {
+        if (this.isConnected) {
+          this._sendMessage(messageArray, resolve, reject);
+        } else {
+          this._connect().then(() => {
+            this._sendMessage(messageArray, resolve, reject);
+          });
+        }
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Disconnects the WebSocket by terminating the connection.
+   * @returns {void}
+   *
+   */
+  disconnect() {
+    if (this.instance) {
+      this.instance.close();
+    }
+    this.isConnected = false;
+  }
+  /**
+   * Connects to the WebSocket server.
+   * @private
+   * @async
+   * @returns {Promise<void>} - A promise that resolves when the connection is established.
+   */
+  _connect() {
+    return new Promise((resolve, reject) => {
+      if (!WsClient || WsClient === null) {
+        reject(new Error("missing WebSocket client"));
+      }
+      this.instance = new WsClient(this.url);
+      this.instance.binaryType = "arraybuffer";
+      this.instance.addEventListener(WebSocketState.OPEN, () => {
+        this.isConnected = true;
+        resolve();
+      });
+      this.instance.addEventListener(WebSocketState.ERROR, (error) => {
+        reject(error);
+      });
+      this.instance.addEventListener(WebSocketState.CLOSE, () => {
+        this.isConnected = false;
+      });
+    });
+  }
+  /**
+   * 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}
+   */
+  _sendMessage(data, resolve, reject) {
+    try {
+      if (this.instance === null || !this.instance) {
+        throw new Error("error websocket not connected");
+      }
+      const arrayBuffer = data.buffer;
+      this.instance.send(arrayBuffer);
+      const handleMessage = (msg) => {
+        if (this.instance === null || !this.instance) {
+          throw new Error("error websocket not connected");
+        }
+        const byteArray = new Int8Array(msg.data);
+        resolve(byteArray);
+        if (this.isDisconnectedAfterMessage) {
+          this.disconnect();
+        }
+        this.instance.removeEventListener(WebSocketState.MESSAGE, handleMessage);
+        this.instance.removeEventListener(WebSocketState.ERROR, handleError);
+      };
+      const handleError = (error) => {
+        reject(error);
+        if (this.instance) {
+          this.instance.removeEventListener(WebSocketState.MESSAGE, handleMessage);
+          this.instance.removeEventListener(WebSocketState.ERROR, handleError);
+        }
+      };
+      if (this.instance) {
+        this.instance.addEventListener(WebSocketState.MESSAGE, handleMessage);
+        this.instance.addEventListener(WebSocketState.ERROR, handleError);
+      }
+    } catch (err) {
+      reject(err);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WebSocketClientBrowser
+});