javonet-nodejs-sdk 2.5.17 → 2.5.18

package/dist/types/sdk/Javonet.d.ts

@@ -1,3 +1,4 @@
+export type ConfigSource = import("../types.d.ts").ConfigSource;
 /**
  * The Javonet class is a singleton class that serves as the entry point for interacting with Javonet.
  * It provides methods to activate and initialize the Javonet SDK.
@@ -28,29 +29,33 @@ export class Javonet {
     /**
      * Initializes Javonet with a custom configuration file taken from external source.
      * Currentyl supported: Configuration file in JSON format
-     * @param config - Path to a configuration file.
+     * @param {string|ConfigSource} config - Path to a configuration file.
      * @returns {ConfigRuntimeFactory} A ConfigRuntimeFactory instance with configuration data.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/configure-channel)
      */
-    static withConfig(config: any): ConfigRuntimeFactory;
+    static withConfig(config: string | ConfigSource): ConfigRuntimeFactory;
     /**
      * Activates Javonet with the provided license key.
      * @param {string} licenseKey - The license key to activate Javonet.
-     * @returns {number} The activation status code.
+     * @returns {void} The activation status code.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/getting-started/activating-javonet)
      */
-    static activate(licenseKey: string): number;
+    static activate(licenseKey: string): void;
+    /**
+     * Gets the runtime information.
+     * @returns {string} The runtime information.
+     */
     static getRuntimeInfo(): string;
     /**
      * Sets the configuration source for the Javonet SDK.
-     *
      * @param {string} configSource - The configuration source.
+     * @returns {void}
      */
-    static setConfigSource(configSource: string): any;
+    static setConfigSource(configSource: string): void;
     /**
      * Sets the working directory for the Javonet SDK.
-     *
      * @param {string} path - The working directory.
+     * @returns {void}
      */
     static setJavonetWorkingDirectory(path: string): void;
 }

package/dist/types/sdk/RuntimeContext.d.ts

@@ -1,3 +1,6 @@
+export type RuntimeNameType = import("../types.d.ts").RuntimeName;
+export type IConnectionData = import("../utils/connectionData/IConnectionData.js").IConnectionData;
+export type Transmitter = typeof import("../core/transmitter/Transmitter.js").Transmitter;
 /**
  * Represents a single context which allows interaction with a selected technology.
  * Refers to a single instance of the called runtime within a particular target OS process.
@@ -10,13 +13,26 @@
  * @class
  */
 export class RuntimeContext {
-    static memoryRuntimeContexts: Map<any, any>;
-    static networkRuntimeContexts: Map<any, any>;
-    static webSocketRuntimeContexts: Map<any, any>;
-    static getInstance(runtimeName: any, connectionData: any): any;
-    constructor(runtimeName: any, connectionData: any);
-    runtimeName: any;
-    connectionData: any;
+    /** @type {Map<string, RuntimeContext>} */
+    static memoryRuntimeContexts: Map<string, RuntimeContext>;
+    /** @type {Map<string, RuntimeContext>} */
+    static networkRuntimeContexts: Map<string, RuntimeContext>;
+    /** @type {Map<string, RuntimeContext>} */
+    static webSocketRuntimeContexts: Map<string, RuntimeContext>;
+    /**
+     * @param {RuntimeNameType} runtimeName
+     * @param {IConnectionData} connectionData
+     * @returns {RuntimeContext}
+     */
+    static getInstance(runtimeName: RuntimeNameType, connectionData: IConnectionData): RuntimeContext;
+    /**
+     * @param {RuntimeNameType} runtimeName
+     * @param {IConnectionData} connectionData
+     */
+    constructor(runtimeName: RuntimeNameType, connectionData: IConnectionData);
+    _isExecuted: boolean;
+    runtimeName: import("../types.d.ts").RuntimeName;
+    connectionData: import("../utils/connectionData/IConnectionData.js").IConnectionData;
     /**
      * Executes the current command. The initial state of RuntimeContext is non-materialized,
      * wrapping either a single command or a chain of recursively nested commands.

package/dist/types/sdk/RuntimeFactory.d.ts

@@ -1,11 +1,17 @@
+/**
+ * @typedef {import('../utils/connectionData/IConnectionData.js').IConnectionData} IConnectionData
+ */
 /**
  * The RuntimeFactory 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)
  */
 export class RuntimeFactory {
-    constructor(connectionData: any);
-    connectionData: any;
+    /**
+     * @param {IConnectionData} connectionData
+     */
+    constructor(connectionData: IConnectionData);
+    connectionData: import("../utils/connectionData/IConnectionData.js").IConnectionData;
     /**
      * Creates RuntimeContext instance to interact with the .NET Framework runtime.
      * @return {RuntimeContext} a RuntimeContext instance for the .NET Framework runtime
@@ -55,4 +61,5 @@ export class RuntimeFactory {
      */
     python27(): RuntimeContext;
 }
+export type IConnectionData = import("../utils/connectionData/IConnectionData.js").IConnectionData;
 import { RuntimeContext } from './RuntimeContext.js';

package/dist/types/sdk/tools/ActivationHelper.d.ts

@@ -0,0 +1,20 @@
+export class ActivationHelper {
+    /** @type {string} */
+    static temporaryLicenseKey: string;
+    /**
+     * @param {string} value
+     */
+    static setTemporaryLicenseKey(value: string): void;
+    /**
+     * @returns {string}
+     */
+    static getTemporaryLicenseKey(): string;
+    /**
+     * @returns {Promise<string>}
+     */
+    static getLicenseKey(): Promise<string>;
+    /**
+     * @returns {string}
+     */
+    static _getLicenseKeyFromFile(): string;
+}

package/dist/types/sdk/tools/JsonResolver.d.ts

@@ -0,0 +1,87 @@
+export type RuntimeChannelType = import("../../types.d.ts").RuntimeChannelType;
+export type ConfigSource = import("../../types.d.ts").ConfigSource;
+export type RuntimeChannel = import("../../types.d.ts").RuntimeChannel;
+export type Runtime = import("../../types.d.ts").Runtime;
+export type Runtimes = import("../../types.d.ts").Runtimes;
+export type RuntimeType = import("../../types.d.ts").RuntimeType;
+export class JsonResolver {
+    /**
+     * @param {string | ConfigSource} configSource
+     */
+    constructor(configSource: string | ConfigSource);
+    /** @type {ConfigSource} */
+    jsonObject: ConfigSource;
+    /** @type {string | ConfigSource} */
+    configSource: string | ConfigSource;
+    /**
+     * @returns {Partial<Runtimes>}
+     */
+    get runtimes(): Partial<Runtimes>;
+    /**
+     * @returns {string}
+     */
+    get licenseKey(): string;
+    /**
+     * @returns {string}
+     */
+    get workingDirectory(): string;
+    /**
+     * @returns {string}
+     */
+    getLicenseKey(): string;
+    /**
+     * @returns {string}
+     */
+    getWorkingDirectory(): string;
+    /**
+     * @param {RuntimeType} runtimeName
+     * @param {string} configName
+     * @returns {RuntimeChannelType}
+     */
+    getChannelType(runtimeName: RuntimeType, configName: string): RuntimeChannelType;
+    /**
+     * @param {RuntimeType} runtimeName
+     * @param {string} configName
+     * @returns {string}
+     */
+    getChannelHost(runtimeName: RuntimeType, configName: string): string;
+    /**
+     * @param {RuntimeType} runtimeName
+     * @param {string} configName
+     * @returns {number|string}
+     */
+    getChannelPort(runtimeName: RuntimeType, configName: string): number | string;
+    /**
+     * @param {RuntimeType} runtimeName
+     * @param {string} configName
+     * @returns {string}
+     */
+    getModules(runtimeName: RuntimeType, configName: string): string;
+    /**
+     * @private
+     * @param {string | ConfigSource} configSource
+     * @returns {ConfigSource}
+     */
+    private _getJsonObject;
+    /**
+     * @private
+     * @param {RuntimeType} runtimeName
+     * @param {string} configName
+     * @returns {Runtime}
+     */
+    private _getRuntime;
+    /**
+     * @private
+     * @param {RuntimeType} runtimeName
+     * @param {string} configName
+     * @returns {string}
+     */
+    private _getRuntimeName;
+    /**
+     * @private
+     * @param {RuntimeType} runtimeName
+     * @param {string} configName
+     * @returns {RuntimeChannel}
+     */
+    private _getChannel;
+}

package/dist/types/utils/Command.d.ts

@@ -1,31 +1,34 @@
+/**
+ * @typedef {import('../types.d.ts').RuntimeName} RuntimeName
+ */
 export class Command {
     /**
-     * @param {any} [response]
-     * @param {number} runtimeName
+     * @param {unknown} response
+     * @param {RuntimeName} runtimeName
+     * @returns {Command}
      */
-    static createResponse(response?: any, runtimeName: number): Command;
+    static createResponse(response: unknown, runtimeName: RuntimeName): Command;
     /**
-     * @param {any} [response]
-     * @param {number} runtimeName
-     * @method
+     * @param {unknown} response
+     * @param {RuntimeName} runtimeName
+     * @returns {Command}
      */
-    static createReference(response?: any, runtimeName: number): Command;
+    static createReference(response: unknown, runtimeName: RuntimeName): Command;
     /**
-     * @param {any} [response]
-     * @param {number} runtimeName
+     * @param {unknown} response
+     * @param {RuntimeName} runtimeName
      * @returns {Command}
-     * @method
      */
-    static createArrayResponse(response?: any, runtimeName: number): Command;
+    static createArrayResponse(response: unknown, runtimeName: RuntimeName): Command;
     /**
      * Constructs a new Command instance.
-     * @param {number} runtimeName - The runtime name associated with the command.
+     * @param {RuntimeName} 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: number, commandType: number, payload?: any);
-    runtimeName: number;
+    constructor(runtimeName: RuntimeName, commandType: number, payload?: any);
+    runtimeName: import("../types.d.ts").RuntimeName;
     commandType: number;
     payload: any;
     dropFirstPayloadArg(): Command;
@@ -40,3 +43,4 @@ export class Command {
      */
     prependArgToPayload(current_command: Command | null): Command;
 }
+export type RuntimeName = import("../types.d.ts").RuntimeName;

package/dist/types/utils/CustomError.d.ts

@@ -1,3 +1,7 @@
 export class CustomError extends Error {
-    constructor(message: any, cause: any);
+    /**
+     * @param {string} message
+     * @param {string} cause
+     */
+    constructor(message: string, cause: string);
 }

package/dist/types/utils/Runtime.d.ts

@@ -18,7 +18,6 @@ export function isEsmRuntime(): boolean;
  * @returns {string}
  */
 export function getRuntimeExtension(): string;
-export function getRequire(callerPath: string): typeof createRequire;
+export function getRequire(callerPath: string): any;
 export function getDirname(): any;
 export function getDependency(dependencyName: string, callerPathOrUrl: string): string;
-import { createRequire } from './CreateRequire.node.js';

package/dist/types/utils/RuntimeNameHandler.d.ts

@@ -1,7 +1,11 @@
+export type RuntimeType = import("../types.d.ts").RuntimeType;
+/**
+ * @typedef {import('../types.d.ts').RuntimeType} RuntimeType
+ */
 export class RuntimeNameHandler {
     /**
      * @param {number} runtimeName
-     * @returns {string}
+     * @returns {RuntimeType}
      */
-    static getName(runtimeName: number): string;
+    static getName(runtimeName: number): RuntimeType;
 }

package/dist/types/utils/Type.d.ts

@@ -11,4 +11,5 @@ export namespace Type {
     let JAVONET_UNSIGNED_LONG_LONG: 9;
     let JAVONET_UNSIGNED_INTEGER: 10;
     let JAVONET_NULL: 11;
+    let JAVONET_VOID: 12;
 }

package/dist/types/utils/TypesHandler.d.ts

@@ -0,0 +1,16 @@
+/**
+ * TypesHandler class provides utilities for converting between types.
+ */
+export class TypesHandler {
+    /**
+     * Converts a JavaScript type to a JType equivalent.
+     * @param {Function} type - The JavaScript type.
+     * @returns {string} The corresponding type name
+     */
+    static convertTypeToJType(type: Function): string;
+    /**
+     * @param {unknown} value
+     * @returns {boolean}
+     */
+    static isPrimitiveOrNullOrUndefined(value: unknown): boolean;
+}

package/dist/types/utils/UtilsConst.d.ts

@@ -0,0 +1,32 @@
+export class UtilsConst {
+    /** @type {string} */
+    static _javonetWorkingDirectory: string;
+    /** @type {string} */
+    static _configSource: string;
+    /** @type {string} */
+    static _licenseKey: string;
+    /**
+     * @param {string} inputPath
+     */
+    static setJavonetWorkingDirectory(inputPath: string): void;
+    /**
+     * @returns {string}
+     */
+    static getJavonetWorkingDirectory(): string;
+    /**
+     * @param {string} value
+     */
+    static setConfigSource(value: string): void;
+    /**
+     * @returns {string}
+     */
+    static getConfigSource(): string;
+    /**
+     * @param {string} value
+     */
+    static setLicenseKey(value: string): void;
+    /**
+     * @returns {string}
+     */
+    static getLicenseKey(): string;
+}

package/dist/types/utils/connectionData/IConnectionData.d.ts

@@ -1,5 +1,18 @@
+/**
+ * @typedef {import('../ConnectionType.js').ConnectionType} ConnectionType
+ */
 export class IConnectionData {
-    get connectionType(): void;
-    get hostname(): void;
-    serializeConnectionData(): void;
+    /**
+     * @returns {ConnectionType}
+     */
+    get connectionType(): ConnectionType;
+    /**
+     * @returns {string}
+     */
+    get hostname(): string;
+    /**
+     * @returns {number[]}
+     */
+    serializeConnectionData(): number[];
 }
+export type ConnectionType = any;

package/dist/types/utils/connectionData/InMemoryConnectionData.d.ts

@@ -1,12 +1,13 @@
+export type ConnectionType = any;
+/**
+ * @typedef {import('../ConnectionType.js').ConnectionType} ConnectionType
+ */
 /**
  * @extends IConnectionData
  */
 export class InMemoryConnectionData extends IConnectionData {
     _connectionType: 0;
     _hostname: string;
-    get connectionType(): 0;
-    get hostname(): string;
-    serializeConnectionData(): number[];
     /**
      * @param {InMemoryConnectionData} other
      * @returns {boolean}

package/dist/types/utils/connectionData/WsConnectionData.d.ts

@@ -1,3 +1,7 @@
+export type ConnectionType = any;
+/**
+ * @typedef {import('../ConnectionType.js').ConnectionType} ConnectionType
+ */
 /**
  * Represents WebSocket connection data.
  * @extends IConnectionData
@@ -11,21 +15,14 @@ export class WsConnectionData extends IConnectionData {
     private _hostname;
     /** @private @type {ConnectionType} */
     private _connectionType;
-    /** @type {ConnectionType} */
-    get connectionType(): {
-        readonly IN_MEMORY: 0;
-        readonly TCP: 1;
-        readonly WEB_SOCKET: 2;
-    };
     /** @type {string} */
     set hostname(value: string);
     /** @type {string} */
     get hostname(): string;
     /**
-     * Serializes the connection data.
-     * @returns {number[]} An array of connection data values.
+     * @param {WsConnectionData} other
+     * @returns {boolean}
      */
-    serializeConnectionData(): number[];
-    equals(other: any): boolean;
+    equals(other: WsConnectionData): boolean;
 }
 import { IConnectionData } from './IConnectionData.js';

package/dist/types/utils/nodejs/connectionData/TcpConnectionData.d.ts

@@ -1,14 +1,21 @@
 /**
+ * @typedef {import('../../ConnectionType.js').ConnectionType} ConnectionType
  * @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 {string} hostname
+     * @param {number} port
+     */
+    constructor(hostname: string, port: number);
+    /** @type {string} */
+    ipAddress: string;
+    /** @type {number} */
+    _port: number;
+    /** @type {string} */
+    _hostname: string;
+    /** @type {ConnectionType} */
+    _connectionType: ConnectionType;
     /**
      * @param {TcpConnectionData} other
      * @returns {boolean}
@@ -16,10 +23,10 @@ export class TcpConnectionData extends IConnectionData {
     equals(other: TcpConnectionData): boolean;
     /**
      * @param {string} hostname
-     * @returns {string|null}
+     * @returns {string}
      */
-    resolveIpAddress(hostname: string): string | null;
-    serializeConnectionData(): 1[];
+    resolveIpAddress(hostname: string): string;
     #private;
 }
+export type ConnectionType = any;
 import { IConnectionData } from '../../connectionData/IConnectionData.js';

package/dist/utils/Command.cjs

@@ -25,7 +25,7 @@ var import_CommandType = require("./CommandType.cjs");
 class Command {
   /**
    * Constructs a new Command instance.
-   * @param {number} runtimeName - The runtime name associated with the command.
+   * @param {RuntimeName} 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
@@ -36,25 +36,25 @@ class Command {
     this.payload = payload;
   }
   /**
-   * @param {any} [response]
-   * @param {number} runtimeName
+   * @param {unknown} response
+   * @param {RuntimeName} runtimeName
+   * @returns {Command}
    */
   static createResponse(response, runtimeName) {
     return new Command(runtimeName, import_CommandType.CommandType.Value, [response]);
   }
   /**
-   * @param {any} [response]
-   * @param {number} runtimeName
-   * @method
+   * @param {unknown} response
+   * @param {RuntimeName} runtimeName
+   * @returns {Command}
    */
   static createReference(response, runtimeName) {
     return new Command(runtimeName, import_CommandType.CommandType.Reference, [response]);
   }
   /**
-   * @param {any} [response]
-   * @param {number} runtimeName
+   * @param {unknown} response
+   * @param {RuntimeName} runtimeName
    * @returns {Command}
-   * @method
    */
   static createArrayResponse(response, runtimeName) {
     return new Command(runtimeName, import_CommandType.CommandType.Array, response);

package/dist/utils/CustomError.cjs

@@ -22,6 +22,10 @@ __export(CustomError_exports, {
 });
 module.exports = __toCommonJS(CustomError_exports);
 class CustomError extends Error {
+  /**
+   * @param {string} message
+   * @param {string} cause
+   */
   constructor(message, cause) {
     super(`${message}: ${cause}`);
     this.name = "CustomError";

package/dist/utils/RuntimeNameHandler.cjs

@@ -25,7 +25,7 @@ var import_RuntimeName = require("./RuntimeName.cjs");
 class RuntimeNameHandler {
   /**
    * @param {number} runtimeName
-   * @returns {string}
+   * @returns {RuntimeType}
    */
   static getName(runtimeName) {
     switch (runtimeName) {

package/dist/utils/Type.cjs

@@ -35,7 +35,8 @@ const Type = (
     JAVONET_DOUBLE: 8,
     JAVONET_UNSIGNED_LONG_LONG: 9,
     JAVONET_UNSIGNED_INTEGER: 10,
-    JAVONET_NULL: 11
+    JAVONET_NULL: 11,
+    JAVONET_VOID: 12
   }
 );
 // Annotate the CommonJS export names for ESM import in node:

package/dist/utils/TypesHandler.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 TypesHandler_exports = {};
+__export(TypesHandler_exports, {
+  TypesHandler: () => TypesHandler
+});
+module.exports = __toCommonJS(TypesHandler_exports);
+class TypesHandler {
+  /**
+   * Converts a JavaScript type to a JType equivalent.
+   * @param {Function} type - The JavaScript type.
+   * @returns {string} The corresponding type name
+   */
+  static convertTypeToJType(type) {
+    switch (type) {
+      case Boolean:
+        return "JType.Boolean";
+      case Number:
+        return "JType.Float";
+      case String:
+        return "JType.String";
+      case Object:
+        return typeof type;
+      default:
+        return typeof type;
+    }
+  }
+  /**
+   * @param {unknown} value
+   * @returns {boolean}
+   */
+  static isPrimitiveOrNullOrUndefined(value) {
+    return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TypesHandler
+});