javonet-nodejs-sdk 2.6.2 → 2.6.4

package/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>}
      */

package/dist/types/sdk/tools/typeParsingFunctions/JavaTypeParsingFunctions.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @param {InvocationContext} invocationContext - InvocationContext pointing to the target object
+ * @returns {Date} A JavaScript Date parsed from the Java timestamp
+ */
+export function parseDate(invocationContext: InvocationContext): Date;
+/**
+ * Mapping of parsing functions for different type signatures.
+ * @type {Map<string, (invocationContext: InvocationContext) => unknown>}
+ */
+export const JavaTypeParsingFunctions: Map<string, (invocationContext: InvocationContext) => unknown>;
+export type InvocationContext = import("../../InvocationContext.js").InvocationContext;

package/dist/types/sdk/tools/typeParsingFunctions/NetcoreTypeParsingFunctions.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @param {InvocationContext} invocationContext - InvocationContext pointing to the target object
+ * @returns {Date} A JavaScript Date parsed from the Java timestamp
+ */
+export function parseDate(invocationContext: InvocationContext): Date;
+/**
+ * Mapping of parsing functions for different type signatures.
+ * @type {Map<string, (invocationContext: InvocationContext) => unknown>}
+ */
+export const NetcoreTypeParsingFunctions: Map<string, (invocationContext: InvocationContext) => unknown>;
+export type InvocationContext = import("../../InvocationContext.js").InvocationContext;

package/dist/types/sdk/tools/typeParsingFunctions/NodejsTypeParsingFunctions.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @param {InvocationContext} invocationContext - InvocationContext pointing to the target object
+ * @returns {Date} A JavaScript Date parsed from the Java timestamp
+ */
+export function parseDate(invocationContext: InvocationContext): Date;
+/**
+ * Mapping of parsing functions for different type signatures.
+ * @type {Map<string, (invocationContext: InvocationContext) => unknown>}
+ */
+export const NodejsTypeParsingFunctions: Map<string, (invocationContext: InvocationContext) => unknown>;
+export type InvocationContext = import("../../InvocationContext.js").InvocationContext;

package/dist/types/sdk/tools/typeParsingFunctions/PythonTypeParsingFunctions.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @param {InvocationContext} invocationContext - InvocationContext pointing to the target object
+ * @returns {Date} A JavaScript Date parsed from the Java timestamp
+ */
+export function parseDatetime(invocationContext: InvocationContext): Date;
+/**
+ * Mapping of parsing functions for different type signatures.
+ * @type {Map<string, (invocationContext: InvocationContext) => unknown>}
+ */
+export const PythonTypeParsingFunctions: Map<string, (invocationContext: InvocationContext) => unknown>;
+export type InvocationContext = import("../../InvocationContext.js").InvocationContext;

package/dist/types/sdk/tools/typeParsingFunctions/TypeParsingUtils.d.ts

@@ -0,0 +1 @@
+export function handleResultWithAction(result: any, action: (arg0: any) => any): any;

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

@@ -44,4 +44,7 @@ export namespace CommandType {
     let AddEventListener: 42;
     let PluginWrapper: 43;
     let GetAsyncOperationResult: 44;
+    let AsKwargs: 45;
+    let GetResultType: 46;
+    let GetGlobalField: 47;
 }

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

@@ -0,0 +1,6 @@
+/**
+ * Checks if a value is a thenable.
+ * @param {any} value - The value to check.
+ * @returns {boolean} True if the value is a thenable, false otherwise.
+ */
+export function isThenable(value: any): boolean;

package/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;

package/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;
 }

package/dist/utils/CommandType.cjs

@@ -68,7 +68,10 @@ const CommandType = (
     ConvertType: 41,
     AddEventListener: 42,
     PluginWrapper: 43,
-    GetAsyncOperationResult: 44
+    GetAsyncOperationResult: 44,
+    AsKwargs: 45,
+    GetResultType: 46,
+    GetGlobalField: 47
   }
 );
 // Annotate the CommonJS export names for ESM import in node:

package/dist/utils/IsThenable.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 IsThenable_exports = {};
+__export(IsThenable_exports, {
+  isThenable: () => isThenable
+});
+module.exports = __toCommonJS(IsThenable_exports);
+function isThenable(value) {
+  return value !== null && typeof value === "object" && "then" in value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isThenable
+});

package/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 = {

package/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 = {

package/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 = {

package/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");

package/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 = {

package/lib/core/handler/AbstractHandler.js

@@ -39,16 +39,18 @@ class AbstractHandler {
     }
 
     /**
-     * 
-     * @param {*} error 
-     * @param {*} class_name 
-     * @returns 
+     *
+     * @param {*} error
+     * @param {*} class_name
+     * @returns
      */
     process_stack_trace(error, class_name) {
         let stackTraceArray = error.stack.split('\n').map((/** @type {string} */ frame) => frame.trim())
         stackTraceArray.forEach((/** @type {string} */ str, /** @type {number} */ index) => {
             if (str.includes(class_name)) {
-                stackTraceArray = stackTraceArray.slice(0, index).filter((/** @type {string} */ s) => !s.includes(class_name))
+                stackTraceArray = stackTraceArray
+                    .slice(0, index)
+                    .filter((/** @type {string} */ s) => !s.includes(class_name))
             }
         })
         error.stack = stackTraceArray.join(' \n ')

package/lib/core/handler/AddEventListenerHandler.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js'
+
+export class AddEventListenerHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`)
+    }
+}

package/lib/core/handler/ArrayReferenceHandler.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js'
+
+export class ArrayReferenceHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`)
+    }
+}

package/lib/core/handler/AsKwargsHandler.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js'
+
+export class AsKwargsHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`)
+    }
+}

package/lib/core/handler/AsOutHandler.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js'
+
+export class AsOutHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`)
+    }
+}

package/lib/core/handler/AsRefHandler.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js'
+
+export class AsRefHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`)
+    }
+}

package/lib/core/handler/CreateNullHandler.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js'
+
+export class CreateNullHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`)
+    }
+}

package/lib/core/handler/ExceptionHandler.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js'
+
+export class ExceptionHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`)
+    }
+}

package/lib/core/handler/GenerateLibHandler.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js'
+
+export class GenerateLibHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`)
+    }
+}

package/lib/core/handler/GetAsyncOperationResultHandler.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js'
+
+export class GetAsyncOperationResultHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`)
+    }
+}

package/lib/core/handler/GetEnumItemHandler.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js'
+
+export class GetEnumItemHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`)
+    }
+}

package/lib/core/handler/GetEnumNameHandler.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js'
+
+export class GetEnumNameHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`)
+    }
+}

package/lib/core/handler/GetEnumValueHandler.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js'
+
+export class GetEnumValueHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`)
+    }
+}

package/lib/core/handler/GetGlobalFieldHandler.js

@@ -0,0 +1,44 @@
+import { AbstractHandler } from './AbstractHandler.js'
+
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
+class GetGlobalFieldHandler extends AbstractHandler {
+    requiredParametersCount = 1
+
+    constructor() {
+        super()
+    }
+
+    /**
+     * @param {Command} command
+     * @returns {any}
+     */
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Invoke Global Field parameters mismatch')
+            }
+            const { payload } = command
+            const fieldName = payload[0]
+
+            if (fieldName in global && typeof global[fieldName] !== 'function') {
+                return global[fieldName]
+            } else {
+                const fields = Object.getOwnPropertyNames(global).filter(
+                    (property) => typeof global[property] !== 'function'
+                )
+                let message = `Field ${fieldName} not found in global. Available fields:\n`
+                fields.forEach((field) => {
+                    message += `${field}\n`
+                })
+                throw new Error(message)
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+export { GetGlobalFieldHandler }

package/lib/core/handler/GetInstanceMethodAsDelegateHandler.js

@@ -66,9 +66,9 @@ class GetInstanceMethodAsDelegateHandler extends AbstractHandler {
      * @returns {Error} The error with detailed message.
      */
     createMethodNotFoundError(type, methodName) {
-        const methods = Object.getOwnPropertyNames(/** @type {{prototype: Object}} */ (type).prototype).filter(
-            (key) => typeof /** @type {any} */ (type).prototype[key] === 'function'
-        )
+        const methods = Object.getOwnPropertyNames(
+            /** @type {{prototype: Object}} */ (type).prototype
+        ).filter((key) => typeof (/** @type {any} */ (type).prototype[key]) === 'function')
         const availableMethods = methods.map((name) => `${name}()`)
         const message = `Method ${methodName} not found in class ${/** @type {{name: string}} */ (type).name}. Available instance public methods:\n${availableMethods.join('\n')}`
         return new Error(message)

package/lib/core/handler/GetModuleHandler.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js'
+
+export class GetModuleHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`)
+    }
+}

package/lib/core/handler/GetRefValueHandler.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js'
+
+export class GetRefValueHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`)
+    }
+}

package/lib/core/handler/GetResultTypeHandler.js

@@ -0,0 +1,29 @@
+// @ts-check
+import { TypesHandler } from '../../utils/TypesHandler.js'
+import { AbstractHandler } from './AbstractHandler.js'
+
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
+/**
+ * GetResultTypeHandler class handles the conversion of JType to Type.
+ */
+class GetResultTypeHandler extends AbstractHandler {
+    constructor() {
+        super()
+        /** @type {number} */
+        this.requiredParametersCount = 1
+    }
+
+    /**
+     * Processes the given command to convert JType to Type.
+     * @param {Command} command - The command to process.
+     * @returns {any} The converted type.
+     */
+    process(command) {
+        return command.payload[0].constructor.name
+    }
+}
+
+export { GetResultTypeHandler }

package/lib/core/handler/GetStaticFieldHandler.js

@@ -43,4 +43,3 @@ class GetStaticFieldHandler extends AbstractHandler {
 }
 
 export { GetStaticFieldHandler }
-

package/lib/core/handler/GetStaticMethodAsDelegateHandler.js

@@ -64,7 +64,9 @@ class GetStaticMethodAsDelegateHandler extends AbstractHandler {
      * @returns {Error} The error with detailed message.
      */
     createMethodNotFoundError(type, methodName) {
-        const methods = Object.keys(type).filter((key) => typeof /** @type {any} */ (type)[key] === 'function')
+        const methods = Object.keys(type).filter(
+            (key) => typeof (/** @type {any} */ (type)[key]) === 'function'
+        )
         const availableMethods = methods.map((name) => `${name}()`)
         const message = `Method ${methodName} not found in class ${/** @type {{name: string}} */ (type).name}. Available public static methods:\n${availableMethods.join('\n')}`
         return new Error(message)

package/lib/core/handler/GetTypeHandler.js

@@ -22,9 +22,9 @@ class GetTypeHandler extends AbstractHandler {
     }
 
     /**
-     * 
-     * @param {Command} command 
-     * @returns 
+     *
+     * @param {Command} command
+     * @returns
      */
     process(command) {
         try {