javonet-ruby-sdk 2.6.3 → 2.6.4

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/configuration/configResolvers/YamlConfigResolver.cjs

@@ -0,0 +1,125 @@
+"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 YamlConfigResolver_exports = {};
+__export(YamlConfigResolver_exports, {
+  YamlConfigResolver: () => YamlConfigResolver
+});
+module.exports = __toCommonJS(YamlConfigResolver_exports);
+var import_js_yaml = __toESM(require("js-yaml"), 1);
+var import_Config = require("../Config.cjs");
+var import_ConfigsDictionary = require("../ConfigsDictionary.cjs");
+var import_ConfigResolver = require("./ConfigResolver.cjs");
+var import_ActivationHelper = require("../../tools/ActivationHelper.cjs");
+class YamlConfigResolver extends import_ConfigResolver.ConfigResolver {
+  /**
+   * Parse YAML string and add configurations.
+   * @param {any} priority
+   * @param {string} yamlString
+   */
+  static addConfigs(priority, yamlString) {
+    if (!yamlString || String(yamlString).trim() === "") {
+      throw new Error("YAML string cannot be null or empty.");
+    }
+    let data;
+    try {
+      data = import_js_yaml.default.load(String(yamlString));
+    } catch (ex) {
+      throw new SyntaxError(`Failed to parse YAML: ${ex}`);
+    }
+    if (typeof data !== "object" || data == null || Array.isArray(data)) {
+      throw new SyntaxError("Root YAML node must be a mapping.");
+    }
+    const root = (
+      /** @type {RootYaml} */
+      data
+    );
+    const licenseKey = root.licenseKey;
+    if (typeof licenseKey === "string") {
+      import_ActivationHelper.ActivationHelper.temporaryLicenseKey = licenseKey.trim();
+    }
+    const configs = root.configurations;
+    if (typeof configs !== "object" || configs == null || Array.isArray(configs)) {
+      throw new Error("YAML must contain 'configurations' mapping.");
+    }
+    for (const [configName, cfg] of Object.entries(configs)) {
+      if (typeof configName !== "string" || configName.trim() === "") {
+        console.log("Skipping entry with empty config name.");
+        continue;
+      }
+      if (typeof cfg !== "object" || cfg == null || Array.isArray(cfg)) {
+        console.log(`Skipping '${configName}': value is not a mapping.`);
+        continue;
+      }
+      try {
+        const runtimeValue = YamlConfigResolver._getRequiredString(cfg, "runtime");
+        const runtimeName = import_ConfigResolver.ConfigResolver.tryParseRuntime(runtimeValue);
+        const host = YamlConfigResolver._getOptionalString(cfg, "host");
+        const connectionData = import_ConfigResolver.ConfigResolver.buildConnectionData(host);
+        const plugins = YamlConfigResolver._getOptionalString(cfg, "plugins");
+        const modules = YamlConfigResolver._getOptionalString(cfg, "modules");
+        const config = new import_Config.Config(runtimeName, connectionData, plugins, modules);
+        import_ConfigsDictionary.ConfigsDictionary.addConfig(configName, priority, config);
+      } catch (ex) {
+        console.log(`Failed to add config '${configName}': ${ex}`);
+      }
+    }
+  }
+  /**
+   * Get required string from mapping, trimmed. Throws if missing/invalid.
+   * @param {Record<string, unknown>} mapping
+   * @param {string} key
+   * @returns {string}
+   * @private
+   */
+  static _getRequiredString(mapping, key) {
+    const value = mapping[key];
+    if (typeof value !== "string" || value.trim() === "") {
+      throw new Error(`Missing or invalid '${key}' property.`);
+    }
+    return value.trim();
+  }
+  /**
+   * Get optional string from mapping, or empty string if missing/not a string.
+   * @param {Record<string, unknown>} mapping
+   * @param {string} key
+   * @returns {string}
+   * @private
+   */
+  static _getOptionalString(mapping, key) {
+    const value = mapping[key];
+    if (typeof value === "string") {
+      return value;
+    }
+    return "";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  YamlConfigResolver
+});

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/tools/JsonResolver.cjs

@@ -42,8 +42,10 @@ let fs = null;
 class JsonResolver {
   /** @type {ConfigSource} */
   jsonObject;
-  /** @type {string | ConfigSource} */
+  /** @type {string} */
   configSource;
+  /** @type {boolean} */
+  isConfigSourcePath = false;
   /**
    * @param {string | ConfigSource} configSource
    */
@@ -149,6 +151,7 @@ class JsonResolver {
         fs = requireDynamic("fs");
       }
       if (fs?.existsSync(configSource)) {
+        this.isConfigSourcePath = true;
         const jsonText = fs.readFileSync(configSource, "utf8");
         if (isValidJson(jsonText)) {
           const parsedFromFile = JSON.parse(jsonText);

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

@@ -12,7 +12,7 @@ export class Transmitter {
     /**
      * @param {string} configSource
      * @returns {void}
-    */
+     */
     static setConfigSource(configSource: string): void;
     /**
      * @param {string} workingDirectory

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/sdk/ConfigRuntimeFactory.d.ts

@@ -8,6 +8,9 @@
  * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
  */
 export class ConfigRuntimeFactory {
+    static _IN_MEMORY_CONNECTION_TYPES: string[];
+    static _WEB_SOCKET_CONNECTION_TYPES: string[];
+    static _TCP_CONNECTION_TYPES: string[];
     /**
      * @param {ConfigSource | string} configSource
      */

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/sdk/Javonet.d.ts

@@ -58,11 +58,25 @@ export class Javonet {
      * @returns {void}
      */
     static setJavonetWorkingDirectory(path: string): void;
+    /**
+     * Adds a configuration to the ConfigSourceResolver with the specified priority and source.
+     * @param {number} priority - The priority of the configuration.
+     * @param {string} configSource - The configuration source.
+     */
+    static addConfig(priority: number, configSource: string): void;
+    /**
+     * Initializes a RuntimeContext instance based on the specified configuration name.
+     * @param {string} configName - The name of the configuration to use.
+     * @returns {RuntimeContext}  A RuntimeContext instance initialized with the specified configuration.
+     */
+    static initializeRc(configName: string): RuntimeContext;
 }
 import { TcpConnectionData } from '../utils/nodejs/connectionData/TcpConnectionData.js';
 import { WsConnectionData } from '../utils/connectionData/WsConnectionData.js';
 import { CommandSerializer } from '../core/protocol/CommandSerializer.js';
 import { CommandDeserializer } from '../core/protocol/CommandDeserializer.js';
+import { ConfigPriority } from './configuration/ConfigPriority.js';
 import { RuntimeFactory } from './RuntimeFactory.js';
 import { ConfigRuntimeFactory } from './ConfigRuntimeFactory.js';
-export { TcpConnectionData, WsConnectionData, CommandSerializer, CommandDeserializer };
+import { RuntimeContext } from './RuntimeContext.js';
+export { TcpConnectionData, WsConnectionData, CommandSerializer, CommandDeserializer, ConfigPriority };

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/sdk/RuntimeFactory.d.ts

@@ -7,6 +7,14 @@
  * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
  */
 export class RuntimeFactory {
+    /**
+     * @param {{ runtime: import("../types.js").RuntimeName; connectionData: import("../utils/connectionData/IConnectionData.js").IConnectionData; modules: any; }} config
+     */
+    static initializeRuntimeContext(config: {
+        runtime: import("../types.js").RuntimeName;
+        connectionData: import("../utils/connectionData/IConnectionData.js").IConnectionData;
+        modules: any;
+    }): RuntimeContext;
     /**
      * @param {IConnectionData} connectionData
      */
@@ -54,6 +62,12 @@ export class RuntimeFactory {
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
      */
     nodejs(): RuntimeContext;
+    /**
+     * Creates RuntimeContext instance to interact with the PHP runtime.
+     * @return {RuntimeContext} a RuntimeContext instance for the PHP runtime
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+     */
+    php(): RuntimeContext;
     /**
      * Creates RuntimeContext instance to interact with the Python runtime.
      * @return {RuntimeContext} a RuntimeContext instance for the Python runtime

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/sdk/configuration/Config.d.ts

@@ -0,0 +1,14 @@
+export class Config {
+    /**
+     * @param {*} runtime
+     * @param {*} connectionData
+     * @param {string} [plugins=""]
+     * @param {string} [modules=""]
+     */
+    constructor(runtime: any, connectionData: any, plugins?: string, modules?: string);
+    runtime: any;
+    connectionData: any;
+    plugins: string;
+    modules: string;
+    toString(): string;
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/sdk/configuration/ConfigPriority.d.ts

@@ -0,0 +1,8 @@
+export namespace ConfigPriority {
+    let RuntimeSpecificEnv: 1;
+    let GlobalEnv: 2;
+    let RuntimeSpecificFile: 3;
+    let GlobalFile: 4;
+    let User: 5;
+    let DefaultLibrary: 6;
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/sdk/configuration/ConfigSourceResolver.d.ts

@@ -0,0 +1,7 @@
+export class ConfigSourceResolver {
+    static addConfigs(priority: any, configSource: any): void;
+    static getConfig(configName: any): any;
+    static clearConfigs(): void;
+    static _getConfigSourceAsString(configSource: any): any;
+    static _parseConfigsAndAddToCollection(priority: any, configString: any): void;
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/sdk/configuration/ConfigsDictionary.d.ts

@@ -0,0 +1,30 @@
+export class ConfigsDictionary {
+    /** @type {Map<string, Map<number, any>>} */
+    static _configurations_collection: Map<string, Map<number, any>>;
+    /**
+     * Normalize priority to a numeric value.
+     * Accepts either a number or an object with a numeric `value` property.
+     * @param {any} priority
+     * @returns {number|undefined}
+     */
+    static _normalizePriority(priority: any): number | undefined;
+    /**
+     * Add a configuration for a given name and priority.
+     * If the same name+priority already exists, it will not be overwritten.
+     * @param {string} name
+     * @param {number|{value:number}} priority
+     * @param {*} config
+     */
+    static addConfig(name: string, priority: number | {
+        value: number;
+    }, config: any): void;
+    /**
+     * Retrieve the configuration with the numerically smallest priority for the given name.
+     * Throws if name is invalid or no configuration is found.
+     * @param {string} name
+     * @returns {*}
+     */
+    static getConfig(name: string): any;
+    /** Clear all stored configurations. */
+    static clearConfigs(): void;
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/sdk/configuration/configResolvers/ConfigResolver.d.ts

@@ -0,0 +1,30 @@
+export class ConfigResolver {
+    /**
+     * Parse a runtime string into the runtime enum/name using RuntimeNameHandler.
+     * @param {string} runtime
+     * @returns {*}
+     */
+    static tryParseRuntime(runtime: string): any;
+    /**
+     * Build appropriate connection data object from a host string.
+     * - empty / null => InMemoryConnectionData
+     * - "inmemory" or "in-memory" => InMemoryConnectionData
+     * - ws:// or wss:// => WsConnectionData(fullAddress)
+     * - tcp://... => parsed by parseTcp
+     * - host:port or host:port/... => TcpConnectionData(host, port) if valid, otherwise InMemoryConnectionData
+     * @param {string} hostValue
+     * @returns {InMemoryConnectionData|WsConnectionData|TcpConnectionData}
+     */
+    static buildConnectionData(hostValue: string): InMemoryConnectionData | WsConnectionData | TcpConnectionData;
+    /**
+     * Parse tcp address portion (after tcp://) into TcpConnectionData.
+     * Expected formats: host:port or host:port/...
+     * Throws Error on invalid format or port.
+     * @param {string} address
+     * @returns {TcpConnectionData}
+     */
+    static parseTcp(address: string): TcpConnectionData;
+}
+import { InMemoryConnectionData } from '../../../utils/connectionData/InMemoryConnectionData.js';
+import { WsConnectionData } from '../../../utils/connectionData/WsConnectionData.js';
+import { TcpConnectionData } from '../../../utils/nodejs/connectionData/TcpConnectionData.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/sdk/configuration/configResolvers/ConnectionStringConfigResolver.d.ts

@@ -0,0 +1,23 @@
+export class ConnectionStringConfigResolver extends ConfigResolver {
+    /**
+     * Parse and add multiple configuration lines from a connection string source.
+     * @param {any} priority
+     * @param {string} connectionStringSource
+     */
+    static addConfigs(priority: any, connectionStringSource: string): void;
+    /**
+     * Extract and set temporary license key from a line like "licensekey=VALUE;..."
+     * @param {string} line
+     * @private
+     */
+    private static _setLicenseKey;
+    /**
+     * Parse semicolon-separated key=value tokens into an object.
+     * Ignores malformed tokens and logs them.
+     * @param {string} line
+     * @returns {Record<string, string>}
+     * @private
+     */
+    private static _parseKeyValues;
+}
+import { ConfigResolver } from './ConfigResolver.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/sdk/configuration/configResolvers/JsonConfigResolver.d.ts

@@ -0,0 +1,26 @@
+export class JsonConfigResolver extends ConfigResolver {
+    /**
+     * Parse and add configurations from a JSON object.
+     * @param {any} priority
+     * @param {Record<string, unknown>} jsonObject
+     */
+    static addConfigs(priority: any, jsonObject: Record<string, unknown>): void;
+    /**
+     * Get a required string property from an object, trimmed.
+     * Throws if missing or empty.
+     * @param {Record<string, unknown>} obj
+     * @param {string} property
+     * @returns {string}
+     * @private
+     */
+    private static _getRequiredString;
+    /**
+     * Get an optional string property; return empty string when missing or not a string.
+     * @param {Record<string, unknown>} obj
+     * @param {string} property
+     * @returns {string}
+     * @private
+     */
+    private static _getOptionalString;
+}
+import { ConfigResolver } from './ConfigResolver.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/sdk/configuration/configResolvers/YamlConfigResolver.d.ts

@@ -0,0 +1,32 @@
+export type RootYaml = {
+    licenseKey?: string;
+    configurations?: Record<string, Record<string, unknown>>;
+};
+/**
+ * @typedef {{ licenseKey?: string, configurations?: Record<string, Record<string, unknown>> }} RootYaml
+ */
+export class YamlConfigResolver extends ConfigResolver {
+    /**
+     * Parse YAML string and add configurations.
+     * @param {any} priority
+     * @param {string} yamlString
+     */
+    static addConfigs(priority: any, yamlString: string): void;
+    /**
+     * Get required string from mapping, trimmed. Throws if missing/invalid.
+     * @param {Record<string, unknown>} mapping
+     * @param {string} key
+     * @returns {string}
+     * @private
+     */
+    private static _getRequiredString;
+    /**
+     * Get optional string from mapping, or empty string if missing/not a string.
+     * @param {Record<string, unknown>} mapping
+     * @param {string} key
+     * @returns {string}
+     * @private
+     */
+    private static _getOptionalString;
+}
+import { ConfigResolver } from './ConfigResolver.js';

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/types/sdk/tools/JsonResolver.d.ts

@@ -11,8 +11,10 @@ export class JsonResolver {
     constructor(configSource: string | ConfigSource);
     /** @type {ConfigSource} */
     jsonObject: ConfigSource;
-    /** @type {string | ConfigSource} */
-    configSource: string | ConfigSource;
+    /** @type {string} */
+    configSource: string;
+    /** @type {boolean} */
+    isConfigSourcePath: boolean;
     /**
      * @returns {Partial<Runtimes>}
      */

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

@@ -18,6 +18,7 @@ export function isEsmRuntime(): boolean;
  * @returns {string}
  */
 export function getRuntimeExtension(): string;
-export function getRequire(callerPath: string): any;
-export function getDirname(): any;
-export function getDependency(dependencyName: string, callerPathOrUrl: string): string;
+export function getRequire(callerPath?: string): any;
+export function getDirname(): string | Error;
+export function getDependency(dependencyName: string, callerPathOrUrl?: string): string;
+export type ConfigSource = import("../types.js").ConfigSource;

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

@@ -8,4 +8,9 @@ export class RuntimeNameHandler {
      * @returns {RuntimeType}
      */
     static getName(runtimeName: number): RuntimeType;
+    /**
+     * @param {string} name
+     * @returns {number}
+     */
+    static getRuntime: (name: string) => number;
 }

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

@@ -55,6 +55,40 @@ class RuntimeNameHandler {
         throw new Error("Invalid runtime name.");
     }
   }
+  /**
+   * @param {string} name
+   * @returns {number}
+   */
+  static getRuntime = (name) => {
+    if (!name || name.trim() === "") {
+      throw new Error("Runtime name cannot be null or whitespace.");
+    }
+    const normalized = name.trim().toLowerCase();
+    switch (normalized) {
+      case "clr":
+        return import_RuntimeName.RuntimeName.Clr;
+      case "go":
+        return import_RuntimeName.RuntimeName.Go;
+      case "jvm":
+        return import_RuntimeName.RuntimeName.Jvm;
+      case "netcore":
+        return import_RuntimeName.RuntimeName.Netcore;
+      case "perl":
+        return import_RuntimeName.RuntimeName.Perl;
+      case "python":
+        return import_RuntimeName.RuntimeName.Python;
+      case "ruby":
+        return import_RuntimeName.RuntimeName.Ruby;
+      case "nodejs":
+        return import_RuntimeName.RuntimeName.Nodejs;
+      case "php":
+        return import_RuntimeName.RuntimeName.Php;
+      case "python27":
+        return import_RuntimeName.RuntimeName.Python27;
+      default:
+        throw new Error(`${name} is not a supported runtime.`);
+    }
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -27,7 +27,7 @@ class InMemoryConnectionData extends import_IConnectionData.IConnectionData {
   constructor() {
     super();
     this._connectionType = import_ConnectionType.ConnectionType.IN_MEMORY;
-    this._hostname = "";
+    this._hostname = "inMemory";
   }
   /**
    * @returns {ConnectionType}
@@ -55,6 +55,12 @@ class InMemoryConnectionData extends import_IConnectionData.IConnectionData {
   equals(other) {
     return other instanceof InMemoryConnectionData;
   }
+  /**
+   * @returns {string}
+   */
+  toString() {
+    return this.hostname;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -58,6 +58,12 @@ class WsConnectionData extends import_IConnectionData.IConnectionData {
   equals(other) {
     return other instanceof WsConnectionData && this._hostname === other.hostname;
   }
+  /**
+   * @returns {string}
+   */
+  toString() {
+    return this.hostname;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -35,7 +35,9 @@ class ExceptionSerializer {
     try {
       this.serializeStackTrace(exception, stackClasses, stackMethods, stackLines, stackFiles);
       exceptionCommand = exceptionCommand.addArgToPayload(this.getExceptionCode(exception));
-      exceptionCommand = exceptionCommand.addArgToPayload(command ? command.toString() : "Command is null");
+      exceptionCommand = exceptionCommand.addArgToPayload(
+        command ? command.toString() : "Command is null"
+      );
       exceptionCommand = exceptionCommand.addArgToPayload(exception.name);
       exceptionCommand = exceptionCommand.addArgToPayload(exception.message);
       exceptionCommand = exceptionCommand.addArgToPayload(stackClasses.join("|"));
@@ -45,7 +47,9 @@ class ExceptionSerializer {
     } catch (e) {
       exceptionCommand = new import_Command.Command(import_RuntimeName.RuntimeName.Nodejs, import_CommandType.CommandType.Exception, []);
       exceptionCommand = exceptionCommand.addArgToPayload(this.getExceptionCode(e));
-      exceptionCommand = exceptionCommand.addArgToPayload(command ? command.toString() : "Command is null");
+      exceptionCommand = exceptionCommand.addArgToPayload(
+        command ? command.toString() : "Command is null"
+      );
       exceptionCommand = exceptionCommand.addArgToPayload("Node.js Exception Serialization Error");
       exceptionCommand = exceptionCommand.addArgToPayload(e.message);
       exceptionCommand = exceptionCommand.addArgToPayload("ExceptionSerializer");

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/utils/nodejs/connectionData/TcpConnectionData.cjs

@@ -81,13 +81,16 @@ class TcpConnectionData extends import_IConnectionData.IConnectionData {
           return hostname;
         } else {
           const dns = requireDynamic("dns");
-          return dns.resolve4(hostname, (err, addresses) => {
-            if (err) {
-              console.error(err);
-              return "";
+          return dns.resolve4(
+            hostname,
+            (err, addresses) => {
+              if (err) {
+                console.error(err);
+                return "";
+              }
+              return addresses[0];
             }
-            return addresses[0];
-          });
+          );
         }
       }
       return "";
@@ -124,6 +127,12 @@ class TcpConnectionData extends import_IConnectionData.IConnectionData {
   #getPortBytes() {
     return [this._port & 255, this._port >> 8];
   }
+  /**
+   * @returns {string}
+   */
+  toString() {
+    return `${this.ipAddress}:${this._port}`;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

data/lib/javonet-ruby-sdk/Binaries/Perl/Linux/X64/deps/lib/perl5/ExtUtils/InstallPaths.pm

@@ -1,5 +1,5 @@
 package ExtUtils::InstallPaths;
-$ExtUtils::InstallPaths::VERSION = '0.014';
+$ExtUtils::InstallPaths::VERSION = '0.015';
 use 5.008;
 use strict;
 use warnings;
@@ -344,7 +344,7 @@ sub install_map {
 
 	my (%map, @skipping);
 	foreach my $type (keys %localdir_for) {
-		next if not $self->is_default_installable($type);
+		next if not -e $localdir_for{$type} and not $self->is_default_installable($type);
 		if (my $dest = $self->install_destination($type)) {
 			$map{$localdir_for{$type}} = $dest;
 		} else {
@@ -406,7 +406,7 @@ ExtUtils::InstallPaths - Build.PL install path logic made easy
 
 =head1 VERSION
 
-version 0.014
+version 0.015
 
 =head1 SYNOPSIS
 
@@ -613,7 +613,7 @@ Ken Williams <kwilliams@cpan.org>
 
 =item *
 
-Leon Timmermans <leont@cpan.org>
+Leon Timmermans <fawaka@gmail.com>
 
 =back