javonet-nodejs-sdk 2.5.16 → 2.5.18

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/CreateRequire.browser.d.ts

@@ -0,0 +1 @@
+export function createRequire(): Error;

package/dist/types/utils/CreateRequire.node.d.ts

@@ -0,0 +1,2 @@
+export { createRequire };
+import { createRequire } from 'module';

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 getDirname(): string;
+export function getRequire(callerPath: string): any;
+export function getDirname(): any;
 export function getDependency(dependencyName: string, callerPathOrUrl: string): string;
-import { createRequire } from 'module';

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/CreateRequire.browser.cjs

@@ -0,0 +1,30 @@
+"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 CreateRequire_browser_exports = {};
+__export(CreateRequire_browser_exports, {
+  createRequire: () => createRequire
+});
+module.exports = __toCommonJS(CreateRequire_browser_exports);
+const createRequire = () => {
+  return new Error("createRequire is not supported in the browser");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRequire
+});

package/dist/utils/CreateRequire.node.cjs

@@ -0,0 +1,28 @@
+"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 CreateRequire_node_exports = {};
+__export(CreateRequire_node_exports, {
+  createRequire: () => import_module.createRequire
+});
+module.exports = __toCommonJS(CreateRequire_node_exports);
+var import_module = require("module");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRequire
+});

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/Runtime.cjs

@@ -1,9 +1,7 @@
 "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)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   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, {
@@ -37,10 +27,11 @@ __export(Runtime_exports, {
   isNodejsRuntime: () => isNodejsRuntime
 });
 module.exports = __toCommonJS(Runtime_exports);
-var import_module = require("module");
-var import_path = __toESM(require("path"), 1);
-var import_url = require("url");
+var import_CreateRequire_node = require("./CreateRequire.node.cjs");
 const import_meta = {};
+let pathToFileURL = null;
+let fileURLToPath = null;
+let path = null;
 function isNodejsRuntime() {
   return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
 }
@@ -60,10 +51,10 @@ const getRequire = (callerPath) => {
         return require;
       }
       if (callerPath === void 0) {
-        return (0, import_module.createRequire)(import_meta.url);
+        return (0, import_CreateRequire_node.createRequire)(import_meta.url);
       }
-      const baseUrl = callerPath?.startsWith("file:") ? callerPath : (0, import_url.pathToFileURL)(callerPath).href;
-      return (0, import_module.createRequire)(baseUrl);
+      const baseUrl = callerPath?.startsWith("file:") ? callerPath : pathToFileURL(callerPath).href;
+      return (0, import_CreateRequire_node.createRequire)(baseUrl);
     }
     return new Error("Runtime not supported");
   } catch (error) {
@@ -71,9 +62,12 @@ const getRequire = (callerPath) => {
   }
 };
 const getDirname = () => {
+  if (isBrowserRuntime()) {
+    return new Error("Runtime not supported");
+  }
   if (isEsmRuntime()) {
-    const __filename2 = (0, import_url.fileURLToPath)(import_meta.url);
-    return import_path.default.dirname(__filename2);
+    const __filename2 = fileURLToPath(import_meta.url);
+    return path.dirname(__filename2);
   }
   return __dirname;
 };
@@ -91,6 +85,18 @@ const getDependency = (dependencyName, callerPathOrUrl) => {
     );
   }
 };
+if (isNodejsRuntime()) {
+  const requireDynamic = getRequire(import_meta.url);
+  if (fileURLToPath === null) {
+    fileURLToPath = requireDynamic("url").fileURLToPath;
+  }
+  if (path === null) {
+    path = requireDynamic("path");
+  }
+  if (pathToFileURL === null) {
+    pathToFileURL = requireDynamic("url").pathToFileURL;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getDependency,