javonet-ruby-sdk 2.5.14 → 2.5.16

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/utils/exception/ExceptionSerializer.d.ts

@@ -0,0 +1,6 @@
+export class ExceptionSerializer {
+    static serializeException(exception: any, command: any): Command;
+    static getExceptionCode(exception: any): 0 | 5 | 6;
+    static serializeStackTrace(exception: any, stackClasses: any, stackMethods: any, stackLines: any, stackFiles: any): void;
+}
+import { Command } from '../Command.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/utils/exception/ExceptionThrower.d.ts

@@ -0,0 +1,4 @@
+export class ExceptionThrower {
+    static throwException(commandException: any): Error;
+    static serializeStack(stackTraceClasses: any, stackTraceMethods: any, stackTraceLines: any, stackTraceFiles: any): string;
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/utils/guid/generateGuid.d.ts

@@ -0,0 +1 @@
+export function generateGUID(): string;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/utils/nodejs/TypesConverter.d.ts

@@ -0,0 +1,48 @@
+/**
+ * ConvertTypeHandler class handles the conversion of JType to Type.
+ */
+export class ConvertTypeHandler {
+    /**
+     * Minimum required parameters count for the command.
+     * @type {number}
+     */
+    requiredParametersCount: number;
+    /**
+     * Processes the given command to convert JType to Type.
+     * @param {Object} command - The command to process.
+     * @returns {any} The converted type.
+     */
+    process(command: Object): any;
+    /**
+     * Validates the command to ensure it has enough parameters.
+     * @param {Object} command - The command to validate.
+     */
+    validateCommand(command: Object): void;
+}
+/**
+ * TypesConverter class provides utilities for converting between types.
+ */
+export class TypesConverter {
+    /**
+     * Converts a JavaScript type to a JType equivalent.
+     * @param {Function} type - The JavaScript type.
+     * @returns {number} The corresponding JType.
+     */
+    static convertTypeToJType(type: Function): number;
+    /**
+     * Converts a JType to a JavaScript type equivalent.
+     * @param {number} type - The JType to convert.
+     * @returns {Function} The corresponding JavaScript type.
+     */
+    static convertJTypeToType(type: number): Function;
+}
+/**
+ * Enum for JType mappings.
+ */
+export type JType = number;
+export namespace JType {
+    let Boolean: number;
+    let Float: number;
+    let String: number;
+    let Null: number;
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/utils/nodejs/connectionData/TcpConnectionData.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @extends IConnectionData
+ */
+export class TcpConnectionData extends IConnectionData {
+    constructor(hostname: any, port: any);
+    _port: any;
+    _hostname: any;
+    _connectionType: 1;
+    ipAddress: string | null;
+    get connectionType(): 1;
+    get hostname(): any;
+    /**
+     * @param {TcpConnectionData} other
+     * @returns {boolean}
+     */
+    equals(other: TcpConnectionData): boolean;
+    /**
+     * @param {string} hostname
+     * @returns {string|null}
+     */
+    resolveIpAddress(hostname: string): string | null;
+    serializeConnectionData(): 1[];
+    #private;
+}
+import { IConnectionData } from '../../connectionData/IConnectionData.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/utils/nodejs/uuid/REGEX.d.ts

@@ -0,0 +1 @@
+export const regex: RegExp;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/utils/nodejs/uuid/rng.d.ts

@@ -0,0 +1 @@
+export function rng(): Uint8Array<ArrayBuffer>;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/utils/nodejs/uuid/stringify.d.ts

@@ -0,0 +1 @@
+export function stringify(arr: any, offset?: number): string;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/utils/nodejs/uuid/v4.d.ts

@@ -0,0 +1 @@
+export function v4(options: any, buf: any, offset: any): any;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/utils/nodejs/uuid/validate.d.ts

@@ -0,0 +1 @@
+export function validate(uuid: any): boolean;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/Command.cjs

@@ -0,0 +1,87 @@
+"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 Command_exports = {};
+__export(Command_exports, {
+  Command: () => Command
+});
+module.exports = __toCommonJS(Command_exports);
+var import_CommandType = require("./CommandType.cjs");
+class Command {
+  /**
+   * Constructs a new Command instance.
+   * @param {number} runtimeName - The runtime name associated with the command.
+   * @param {number} commandType - The type of the command.
+   * @param {any} [payload] - The optional payload of the command.
+   * @method
+   */
+  constructor(runtimeName, commandType, payload = []) {
+    this.runtimeName = runtimeName;
+    this.commandType = commandType;
+    this.payload = payload;
+  }
+  /**
+   * @param {any} [response]
+   * @param {number} runtimeName
+   */
+  static createResponse(response, runtimeName) {
+    return new Command(runtimeName, import_CommandType.CommandType.Value, [response]);
+  }
+  /**
+   * @param {any} [response]
+   * @param {number} runtimeName
+   * @method
+   */
+  static createReference(response, runtimeName) {
+    return new Command(runtimeName, import_CommandType.CommandType.Reference, [response]);
+  }
+  /**
+   * @param {any} [response]
+   * @param {number} runtimeName
+   * @returns {Command}
+   * @method
+   */
+  static createArrayResponse(response, runtimeName) {
+    return new Command(runtimeName, import_CommandType.CommandType.Array, response);
+  }
+  dropFirstPayloadArg() {
+    return new Command(this.runtimeName, this.commandType, this.payload.slice(1));
+  }
+  /**
+   * @param {any} arg
+   * @returns {Command}
+   */
+  addArgToPayload(arg) {
+    return new Command(this.runtimeName, this.commandType, this.payload.concat(arg));
+  }
+  /**
+   * @param {Command|null} current_command
+   * @returns {Command}
+   */
+  prependArgToPayload(current_command) {
+    if (current_command == null) {
+      return new Command(this.runtimeName, this.commandType, this.payload);
+    } else {
+      return new Command(this.runtimeName, this.commandType, [current_command].concat(this.payload));
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Command
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/CommandType.cjs

@@ -0,0 +1,74 @@
+"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 CommandType_exports = {};
+__export(CommandType_exports, {
+  CommandType: () => CommandType
+});
+module.exports = __toCommonJS(CommandType_exports);
+const CommandType = (
+  /** @type {const} */
+  {
+    Value: 0,
+    LoadLibrary: 1,
+    InvokeStaticMethod: 2,
+    GetStaticField: 3,
+    SetStaticField: 4,
+    CreateClassInstance: 5,
+    GetType: 6,
+    Reference: 7,
+    GetModule: 8,
+    InvokeInstanceMethod: 9,
+    Exception: 10,
+    HeartBeat: 11,
+    Cast: 12,
+    GetInstanceField: 13,
+    Optimize: 14,
+    GenerateLib: 15,
+    InvokeGlobalFunction: 16,
+    DestructReference: 17,
+    ArrayReference: 18,
+    ArrayGetItem: 19,
+    ArrayGetSize: 20,
+    ArrayGetRank: 21,
+    ArraySetItem: 22,
+    Array: 23,
+    RetrieveArray: 24,
+    SetInstanceField: 25,
+    InvokeGenericStaticMethod: 26,
+    InvokeGenericMethod: 27,
+    GetEnumItem: 28,
+    GetEnumName: 29,
+    GetEnumValue: 30,
+    AsRef: 31,
+    AsOut: 32,
+    GetRefValue: 33,
+    EnableNamespace: 34,
+    EnableType: 35,
+    CreateNull: 36,
+    GetStaticMethodAsDelegate: 37,
+    GetInstanceMethodAsDelegate: 38,
+    PassDelegate: 39,
+    InvokeDelegate: 40,
+    ConvertType: 41
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CommandType
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/ConnectionType.cjs

@@ -0,0 +1,35 @@
+"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 ConnectionType_exports = {};
+__export(ConnectionType_exports, {
+  ConnectionType: () => ConnectionType
+});
+module.exports = __toCommonJS(ConnectionType_exports);
+const ConnectionType = (
+  /** @type {const} */
+  {
+    IN_MEMORY: 0,
+    TCP: 1,
+    WEB_SOCKET: 2
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConnectionType
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/CustomError.cjs

@@ -0,0 +1,33 @@
+"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 CustomError_exports = {};
+__export(CustomError_exports, {
+  CustomError: () => CustomError
+});
+module.exports = __toCommonJS(CustomError_exports);
+class CustomError extends Error {
+  constructor(message, cause) {
+    super(`${message}: ${cause}`);
+    this.name = "CustomError";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CustomError
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/ExceptionType.cjs

@@ -0,0 +1,40 @@
+"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 ExceptionType_exports = {};
+__export(ExceptionType_exports, {
+  ExceptionType: () => ExceptionType
+});
+module.exports = __toCommonJS(ExceptionType_exports);
+const ExceptionType = (
+  /** @type {const} */
+  {
+    EXCEPTION: 0,
+    IO_EXCEPTION: 1,
+    FILE_NOT_FOUND_EXCEPTION: 2,
+    RUNTIME_EXCEPTION: 3,
+    ARITHMETIC_EXCEPTION: 4,
+    ILLEGAL_ARGUMENT_EXCEPTION: 5,
+    INDEX_OUT_OF_BOUNDS_EXCEPTION: 6,
+    NULL_POINTER_EXCEPTION: 7
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExceptionType
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/Runtime.cjs

@@ -0,0 +1,103 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Runtime_exports = {};
+__export(Runtime_exports, {
+  getDependency: () => getDependency,
+  getDirname: () => getDirname,
+  getRequire: () => getRequire,
+  getRuntimeExtension: () => getRuntimeExtension,
+  isBrowserRuntime: () => isBrowserRuntime,
+  isEsmRuntime: () => isEsmRuntime,
+  isNodejsRuntime: () => isNodejsRuntime
+});
+module.exports = __toCommonJS(Runtime_exports);
+var import_module = require("module");
+var import_path = __toESM(require("path"), 1);
+var import_url = require("url");
+const import_meta = {};
+function isNodejsRuntime() {
+  return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+}
+function isBrowserRuntime() {
+  return typeof window !== "undefined" && typeof window.document !== "undefined";
+}
+function isEsmRuntime() {
+  return typeof __filename === "undefined";
+}
+function getRuntimeExtension() {
+  return isEsmRuntime() ? "js" : "cjs";
+}
+const getRequire = (callerPath) => {
+  try {
+    if (isNodejsRuntime()) {
+      if (typeof require !== "undefined") {
+        return require;
+      }
+      if (callerPath === void 0) {
+        return (0, import_module.createRequire)(import_meta.url);
+      }
+      const baseUrl = callerPath?.startsWith("file:") ? callerPath : (0, import_url.pathToFileURL)(callerPath).href;
+      return (0, import_module.createRequire)(baseUrl);
+    }
+    return new Error("Runtime not supported");
+  } catch (error) {
+    throw error;
+  }
+};
+const getDirname = () => {
+  if (isEsmRuntime()) {
+    const __filename2 = (0, import_url.fileURLToPath)(import_meta.url);
+    return import_path.default.dirname(__filename2);
+  }
+  return __dirname;
+};
+const getDependency = (dependencyName, callerPathOrUrl) => {
+  try {
+    let baseUrl = callerPathOrUrl;
+    if (!baseUrl && typeof __filename !== "undefined") {
+      baseUrl = __filename;
+    }
+    const contextualRequire = getRequire(baseUrl);
+    return contextualRequire.resolve(dependencyName);
+  } catch (error) {
+    throw new Error(
+      `Failed to resolve dependency '${dependencyName}' from '${callerPathOrUrl}': ${error.message}`
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDependency,
+  getDirname,
+  getRequire,
+  getRuntimeExtension,
+  isBrowserRuntime,
+  isEsmRuntime,
+  isNodejsRuntime
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/RuntimeLogger.cjs

@@ -0,0 +1,63 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var RuntimeLogger_exports = {};
+__export(RuntimeLogger_exports, {
+  RuntimeLogger: () => RuntimeLogger
+});
+module.exports = __toCommonJS(RuntimeLogger_exports);
+const import_meta = {};
+var import_Runtime = require("./Runtime.cjs");
+let os = null;
+let process = null;
+const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
+if ((0, import_Runtime.isNodejsRuntime)()) {
+  try {
+    os = requireDynamic("os");
+    process = requireDynamic("process");
+  } catch (error) {
+    throw error;
+  }
+}
+class RuntimeLogger {
+  static getRuntimeInfo() {
+    try {
+      return `JavaScript Managed Runtime Info:
+Node.js Version: ${process?.version}
+OS Version: ${os?.type()} ${os?.release()}
+Process Architecture: ${os?.arch()}
+Current Directory: ${process?.cwd()}
+`;
+    } catch (e) {
+      return "JavaScript Managed Runtime Info: Error while fetching runtime info";
+    }
+  }
+  static printRuntimeInfo() {
+    if (this.notLoggedYet) {
+      console.log(this.getRuntimeInfo());
+      this.notLoggedYet = false;
+    }
+  }
+}
+__publicField(RuntimeLogger, "notLoggedYet", true);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RuntimeLogger
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/RuntimeLoggerBrowser.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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var RuntimeLoggerBrowser_exports = {};
+__export(RuntimeLoggerBrowser_exports, {
+  RuntimeLoggerBrowser: () => RuntimeLoggerBrowser
+});
+module.exports = __toCommonJS(RuntimeLoggerBrowser_exports);
+class RuntimeLoggerBrowser {
+  /**
+   * Gets runtime information in a browser environment.
+   * @method
+   * @returns {string}
+   */
+  static getRuntimeInfo() {
+    try {
+      return `JavaScript Managed Runtime Info:
+User-Agent: ${navigator.userAgent}
+Language: ${navigator.language}
+`;
+    } catch (error) {
+      return "JavaScript Managed Runtime Info: Error while fetching runtime info";
+    }
+  }
+  /**
+   * Prints runtime information to the console.
+   * @method
+   * @returns {void}
+   */
+  static printRuntimeInfo() {
+    if (this.notLoggedYet) {
+      console.log(this.getRuntimeInfo());
+      this.notLoggedYet = false;
+    }
+  }
+}
+__publicField(RuntimeLoggerBrowser, "notLoggedYet", true);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RuntimeLoggerBrowser
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/RuntimeName.cjs

@@ -0,0 +1,43 @@
+"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 RuntimeName_exports = {};
+__export(RuntimeName_exports, {
+  RuntimeName: () => RuntimeName
+});
+module.exports = __toCommonJS(RuntimeName_exports);
+const RuntimeName = (
+  /** @type {const} */
+  {
+    Clr: 0,
+    Go: 1,
+    Jvm: 2,
+    Netcore: 3,
+    Perl: 4,
+    Python: 5,
+    Ruby: 6,
+    Nodejs: 7,
+    Cpp: 8,
+    Php: 9,
+    Python27: 10
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RuntimeName
+});