javonet-nodejs-sdk 2.5.17 → 2.5.19

package/dist/core/handler/AbstractHandler.cjs

@@ -23,26 +23,43 @@ __export(AbstractHandler_exports, {
 module.exports = __toCommonJS(AbstractHandler_exports);
 var import_Command = require("../../utils/Command.cjs");
 class AbstractHandler {
+  /**
+   * @type {Record<number, AbstractHandler>}
+   */
   handlers = [];
   constructor() {
     if (new.target === AbstractHandler) throw new TypeError("You cannot instantiate abstract class");
   }
-  // eslint-disable-next-line no-unused-vars
+  /**
+   * @param {Command} command
+   */
   process(command) {
     throw new Error("process must be implemented");
   }
+  /**
+   * @param {Command} command
+   */
   handleCommand(command) {
     this.iterate(command);
     return this.process(command);
   }
-  iterate(cmd) {
-    for (let i = 0; i < cmd.payload.length; i++) {
-      if (cmd.payload[i] instanceof import_Command.Command) {
-        let inner = cmd.payload[i];
-        cmd.payload[i] = this.handlers[inner.commandType].handleCommand(inner);
+  /**
+   * @param {Command} command
+   */
+  iterate(command) {
+    for (let i = 0; i < command.payload.length; i++) {
+      if (command.payload[i] instanceof import_Command.Command) {
+        let inner = command.payload[i];
+        command.payload[i] = this.handlers[inner.commandType].handleCommand(inner);
       }
     }
   }
+  /**
+   * 
+   * @param {*} error 
+   * @param {*} class_name 
+   * @returns 
+   */
   process_stack_trace(error, class_name) {
     let stackTraceArray = error.stack.split("\n").map((frame) => frame.trim());
     stackTraceArray.forEach((str, index) => {

package/dist/core/handler/ArrayGetItemHandler.cjs

@@ -27,6 +27,9 @@ class ArrayGetItemHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {
@@ -40,7 +43,7 @@ class ArrayGetItemHandler extends import_AbstractHandler.AbstractHandler {
         indexes = command.payload.slice(1);
       }
       if (indexes.length === 1) {
-        return array[indexes];
+        return array[indexes[0]];
       } else {
         let array_copy = [...array];
         for (let i = 0; i < indexes.length; i++) {

package/dist/core/handler/ArrayGetRankHandler.cjs

@@ -27,6 +27,9 @@ class ArrayGetRankHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {

package/dist/core/handler/ArrayGetSizeHandler.cjs

@@ -27,6 +27,9 @@ class ArrayGetSizeHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {

package/dist/core/handler/ArrayHandler.cjs

@@ -26,6 +26,9 @@ class ArrayHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       let processedArray = command.payload;

package/dist/core/handler/ArraySetItemHandler.cjs

@@ -27,6 +27,9 @@ class ArraySetItemHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {
@@ -41,7 +44,7 @@ class ArraySetItemHandler extends import_AbstractHandler.AbstractHandler {
         indexes = [command.payload[1]];
       }
       if (indexes.length === 1) {
-        array[indexes] = value;
+        array[indexes[0]] = value;
       } else {
         for (let i = 0; i < indexes.length - 1; i++) {
           array = array[indexes[i]];

package/dist/core/handler/CastingHandler.cjs

@@ -23,7 +23,9 @@ __export(CastingHandler_exports, {
 module.exports = __toCommonJS(CastingHandler_exports);
 var import_AbstractHandler = require("./AbstractHandler.cjs");
 class CastingHandler extends import_AbstractHandler.AbstractHandler {
-  // eslint-disable-next-line no-unused-vars
+  /**
+   * @param {Command} command
+   */
   process(command) {
     throw new Error(`Dynamically typed languages are not supporting casting`);
   }

package/dist/core/handler/ConvertTypeHandler.cjs

@@ -21,7 +21,7 @@ __export(ConvertTypeHandler_exports, {
   ConvertTypeHandler: () => ConvertTypeHandler
 });
 module.exports = __toCommonJS(ConvertTypeHandler_exports);
-var import_TypesConverter = require("../../utils/nodejs/TypesConverter.cjs");
+var import_TypesHandler = require("../../utils/TypesHandler.cjs");
 var import_AbstractHandler = require("./AbstractHandler.cjs");
 class ConvertTypeHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
@@ -30,16 +30,16 @@ class ConvertTypeHandler extends import_AbstractHandler.AbstractHandler {
   }
   /**
    * Processes the given command to convert JType to Type.
-   * @param {Object} command - The command to process.
+   * @param {Command} command - The command to process.
    * @returns {any} The converted type.
    */
   process(command) {
     this.validateCommand(command);
-    return import_TypesConverter.TypesConverter.convertJTypeToType(command.payload[0]);
+    return import_TypesHandler.TypesHandler.convertTypeToJType(command.payload[0]);
   }
   /**
    * Validates the command to ensure it has enough parameters.
-   * @param {Object} command - The command to validate.
+   * @param {Command} command - The command to validate.
    */
   validateCommand(command) {
     if (command.payload.length < this.requiredParametersCount) {

package/dist/core/handler/CreateClassInstanceHandler.cjs

@@ -27,6 +27,9 @@ class CreateClassInstanceHandler extends import_AbstractHandler.AbstractHandler
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {
@@ -36,8 +39,8 @@ class CreateClassInstanceHandler extends import_AbstractHandler.AbstractHandler
       let constructorArguments = command.payload.slice(1);
       let instance = new clazz(...constructorArguments);
       if (typeof instance === "undefined") {
-        let methods = Object.getOwnPropertyNames(type).filter(function(property) {
-          return typeof type[property] === "function";
+        let methods = Object.getOwnPropertyNames(clazz).filter(function(property) {
+          return typeof clazz[property] === "function";
         });
         let message = `Method 'constructor' not found in class. Available methods:
 `;

package/dist/core/handler/DestructReferenceHandler.cjs

@@ -27,6 +27,9 @@ class DestructReferenceHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       let cache = import_ReferencesCache.ReferencesCache.getInstance();

package/dist/core/handler/EnableNamespaceHandler.cjs

@@ -28,6 +28,9 @@ class EnableNamespaceHandler extends import_AbstractHandler.AbstractHandler {
     super();
     this.requiredParametersCount = 1;
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {

package/dist/core/handler/EnableTypeHandler.cjs

@@ -28,6 +28,9 @@ class EnableTypeHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {

package/dist/core/handler/GetGlobalStaticFieldHandler.cjs

@@ -27,6 +27,9 @@ class GetGlobalStaticFieldHandler extends import_AbstractHandler.AbstractHandler
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {

package/dist/core/handler/GetInstanceFieldHandler.cjs

@@ -27,6 +27,9 @@ class GetInstanceFieldHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {

package/dist/core/handler/GetInstanceMethodAsDelegateHandler.cjs

@@ -44,6 +44,9 @@ class GetInstanceMethodAsDelegateHandler extends import_AbstractHandler.Abstract
     this.instance = command.payload[0];
     const methodName = command.payload[1];
     this.args = command.payload.length > 2 ? command.payload.slice(2) : [];
+    if (!this.instance) {
+      throw new Error("Instance is null or undefined");
+    }
     this.method = this.getMethod(this.instance, methodName);
     if (!this.method) {
       throw this.createMethodNotFoundError(this.instance, methodName);
@@ -58,7 +61,10 @@ class GetInstanceMethodAsDelegateHandler extends import_AbstractHandler.Abstract
    * @returns {Function|null} The found method or null if not found.
    */
   getMethod(type, methodName) {
-    const method = type[methodName];
+    const method = (
+      /** @type {any} */
+      type[methodName]
+    );
     return typeof method === "function" ? method : null;
   }
   /**
@@ -68,11 +74,16 @@ class GetInstanceMethodAsDelegateHandler extends import_AbstractHandler.Abstract
    * @returns {Error} The error with detailed message.
    */
   createMethodNotFoundError(type, methodName) {
-    const methods = Object.getOwnPropertyNames(type.prototype).filter(
-      (key) => typeof 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}. Available instance public methods:
+    const message = `Method ${methodName} not found in class ${/** @type {{name: string}} */
+    type.name}. Available instance public methods:
 ${availableMethods.join("\n")}`;
     return new Error(message);
   }

package/dist/core/handler/GetStaticFieldHandler.cjs

@@ -27,6 +27,10 @@ class GetStaticFieldHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   * @returns {any}
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {

package/dist/core/handler/GetStaticMethodAsDelegateHandler.cjs

@@ -33,7 +33,6 @@ class GetStaticMethodAsDelegateHandler extends import_AbstractHandler.AbstractHa
   /**
    * Processes a command to retrieve a static method as a delegate.
    * @param {Command} command - The command containing payload data.
-   * @param {Array<*>} command.payload - The payload containing type, method name, and arguments.
    * @returns {Function} The delegate for the static method.
    * @throws {Error} If the parameters mismatch or the method cannot be found.
    */
@@ -55,12 +54,13 @@ class GetStaticMethodAsDelegateHandler extends import_AbstractHandler.AbstractHa
    * Retrieves the method from the type.
    * @param {Object} type - The class or constructor to search for the method.
    * @param {string} methodName - The name of the method.
-   * @param {Array<Function>} argsType - The argument types.
-   * @param {Object} modifier - Parameter modifier (not used in JS implementation).
    * @returns {Function|null} The found method or null if not found.
    */
   getMethod(type, methodName) {
-    const method = type[methodName];
+    const method = (
+      /** @type {any} */
+      type[methodName]
+    );
     return typeof method === "function" ? method : null;
   }
   /**
@@ -70,9 +70,11 @@ class GetStaticMethodAsDelegateHandler extends import_AbstractHandler.AbstractHa
    * @returns {Error} The error with detailed message.
    */
   createMethodNotFoundError(type, methodName) {
-    const methods = Object.keys(type).filter((key) => typeof 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}. Available public static methods:
+    const message = `Method ${methodName} not found in class ${/** @type {{name: string}} */
+    type.name}. Available public static methods:
 ${availableMethods.join("\n")}`;
     return new Error(message);
   }

package/dist/core/handler/GetTypeHandler.cjs

@@ -35,6 +35,11 @@ class GetTypeHandler extends import_AbstractHandler.AbstractHandler {
     this.typeCache = new import_TypeCache.TypeCache();
     this.loadLibaryHandler = new import_LoadLibraryHandler.LoadLibraryHandler();
   }
+  /**
+   * 
+   * @param {Command} command 
+   * @returns 
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {
@@ -43,7 +48,10 @@ class GetTypeHandler extends import_AbstractHandler.AbstractHandler {
       const { payload } = command;
       let typeName = payload[0];
       typeName = typeName.replace(".js", "");
-      let typeToReturn = global[typeName];
+      const typeToReturn = (
+        /** @type {any} */
+        global[typeName]
+      );
       if (typeToReturn === void 0) {
         let message = `Type ${typeName} not found
 `;
@@ -69,7 +77,7 @@ Allowed types: ${allowed_types}`
     }
   }
   getAvailableTypes() {
-    let availableTypes = [];
+    const availableTypes = [];
     this.loadLibaryHandler.getLoadedLibraries().forEach((lib) => {
       const dynamicRequire = (0, import_Runtime.getRequire)(import_meta.url);
       const moduleExports = dynamicRequire(`${lib}`);

package/dist/core/handler/Handler.cjs

@@ -50,16 +50,10 @@ var import_InvokeDelegateHandler = require("./InvokeDelegateHandler.cjs");
 var import_InvokeGlobalFunctionHandler = require("./InvokeGlobalFunctionHandler.cjs");
 var import_CommandType = require("../../utils/CommandType.cjs");
 var import_Command = require("../../utils/Command.cjs");
+var import_TypesHandler = require("../../utils/TypesHandler.cjs");
 var import_ExceptionSerializer = require("../../utils/exception/ExceptionSerializer.cjs");
 var import_ConvertTypeHandler = require("./ConvertTypeHandler.cjs");
 var import_AbstractHandler = require("./AbstractHandler.cjs");
-function isResponseSimpleType(response) {
-  let type = typeof response;
-  return ["string", "boolean", "number"].includes(type);
-}
-function isResponseNull(response) {
-  return response === null;
-}
 const handlers = {
   [import_CommandType.CommandType.Value]: new import_ValueHandler.ValueHandler(),
   [import_CommandType.CommandType.LoadLibrary]: new import_LoadLibraryHandler.LoadLibraryHandler(),
@@ -94,13 +88,16 @@ class Handler {
    */
   constructor(interpreter) {
     this.interpreter = interpreter;
-    handlers[import_CommandType.CommandType.PassDelegate] = new import_PassDelegateHandler.PassDelegateHandler(interpreter);
+    if (!this.interpreter) {
+      throw new Error("interpreter is undefined in Handler constructor");
+    }
+    handlers[import_CommandType.CommandType.PassDelegate] = new import_PassDelegateHandler.PassDelegateHandler(this.interpreter);
     Object.keys(handlers).forEach((commandTypeHandler) => {
       handlers[commandTypeHandler].handlers = handlers;
     });
   }
   /**
-   * @param {{ commandType: number; payload: any[]; runtimeName: number; }} command
+   * @param {Command} command
    */
   handleCommand(command) {
     try {
@@ -116,11 +113,11 @@ class Handler {
   }
   /**
    * @param {any} response
-   * @param {number} runtimeName
+   * @param {RuntimeName} runtimeName
    * @returns {Command}
    */
   parseCommand(response, runtimeName) {
-    if (isResponseNull(response) || isResponseSimpleType(response)) {
+    if (import_TypesHandler.TypesHandler.isPrimitiveOrNullOrUndefined(response)) {
       return import_Command.Command.createResponse(response, runtimeName);
     } else {
       let cache = import_ReferencesCache.ReferencesCache.getInstance();

package/dist/core/handler/InvokeGlobalFunctionHandler.cjs

@@ -27,6 +27,9 @@ class InvokeGlobalFunctionHandler extends import_AbstractHandler.AbstractHandler
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {

package/dist/core/handler/InvokeInstanceMethodHandler.cjs

@@ -27,6 +27,9 @@ class InvokeInstanceMethodHandler extends import_AbstractHandler.AbstractHandler
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {

package/dist/core/handler/InvokeStaticMethodHandler.cjs

@@ -27,6 +27,9 @@ class InvokeStaticMethodHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {

package/dist/core/handler/LoadLibraryHandler.cjs

@@ -27,10 +27,14 @@ const import_meta = {};
 const dynamicImport = (0, import_Runtime.getRequire)(import_meta.url);
 class LoadLibraryHandler extends import_AbstractHandler.AbstractHandler {
   requiredParametersCount = 1;
+  /** @type {string[]} */
   static loadedLibraries = [];
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     if (command.payload.length < this.requiredParametersCount) {
       throw new Error("Load Library parameters mismatch");

package/dist/core/handler/SetGlobalStaticFieldHandler.cjs

@@ -27,6 +27,9 @@ class SetGlobalStaticFieldHandler extends import_AbstractHandler.AbstractHandler
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {

package/dist/core/handler/SetInstanceFieldHandler.cjs

@@ -27,6 +27,9 @@ class SetInstanceFieldHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {

package/dist/core/handler/SetStaticFieldHandler.cjs

@@ -27,6 +27,9 @@ class SetStaticFieldHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   */
   process(command) {
     try {
       if (command.payload.length < this.requiredParametersCount) {

package/dist/core/handler/ValueHandler.cjs

@@ -26,6 +26,10 @@ class ValueHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   * @returns {unknown}
+   */
   process(command) {
     const { payload } = command;
     return payload[0];

package/dist/core/interpreter/Interpreter.cjs

@@ -38,7 +38,8 @@ if (!_TransmitterWebsocket) {
 }
 const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 class Interpreter {
-  handler;
+  /** @type {Handler | null} */
+  handler = null;
   /**
    *
    * @param {Command} command
@@ -47,21 +48,24 @@ class Interpreter {
    */
   async executeAsync(command, connectionData) {
     try {
+      if (!this.handler) {
+        this.handler = new import_Handler.Handler(this);
+      }
       let messageByteArray = new import_CommandSerializer.CommandSerializer().serialize(command, connectionData);
-      let responseByteArray;
+      let responseByteArray = void 0;
       if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs && connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
         if ((0, import_Runtime.isNodejsRuntime)()) {
           if (!_Receiver) {
             const { Receiver } = require("../receiver/Receiver.cjs");
             _Receiver = Receiver;
           }
-          responseByteArray = _Receiver.sendCommand(messageByteArray);
+          responseByteArray = _Receiver?.sendCommand(messageByteArray);
         } else {
           throw new Error("Node.js runtime not found");
         }
       } else if (connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
         try {
-          const _response = await _TransmitterWebsocket.sendCommand(
+          const _response = await _TransmitterWebsocket?.sendCommand(
             messageByteArray,
             connectionData
           );
@@ -80,11 +84,14 @@ class Interpreter {
             const { Transmitter } = require("../transmitter/Transmitter.cjs");
             _Transmitter = Transmitter;
           }
-          responseByteArray = await _Transmitter.sendCommand(messageByteArray);
+          responseByteArray = await _Transmitter?.sendCommand(messageByteArray);
         } else {
           throw new Error("Allowed only to run in nodejs runtime");
         }
       }
+      if (!responseByteArray) {
+        throw new Error("No response received from Transmitter");
+      }
       return new import_CommandDeserializer.CommandDeserializer(responseByteArray).deserialize();
     } catch (error) {
       throw error;
@@ -93,23 +100,29 @@ class Interpreter {
   /**
    *
    * @param {Command} command
-   * @param {WsConnectionData} connectionData
-   * @returns {Promise<Command>}
+   * @param {IConnectionData} connectionData
+   * @returns {Command | Promise<Command>}
    */
   execute(command, connectionData) {
     try {
+      if (!this.handler) {
+        this.handler = new import_Handler.Handler(this);
+      }
       let messageByteArray = new import_CommandSerializer.CommandSerializer().serialize(command, connectionData);
-      let responseByteArray;
+      let responseByteArray = void 0;
       if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs && connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
         if ((0, import_Runtime.isNodejsRuntime)()) {
           if (!_Receiver) {
             const { Receiver } = require("../receiver/Receiver.cjs");
             _Receiver = Receiver;
           }
-          responseByteArray = _Receiver.sendCommand(messageByteArray);
+          responseByteArray = _Receiver?.sendCommand(messageByteArray);
         }
       } else if (connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
-        const promise = _TransmitterWebsocket.sendCommand(messageByteArray, connectionData);
+        const promise = _TransmitterWebsocket?.sendCommand(messageByteArray, connectionData);
+        if (!promise) {
+          throw new Error("TransmitterWebsocket not found");
+        }
         return promise.then((_response) => {
           if (_response) {
             const command2 = new import_CommandDeserializer.CommandDeserializer(_response).deserialize();
@@ -126,11 +139,14 @@ class Interpreter {
             const { Transmitter } = require("../transmitter/Transmitter.cjs");
             _Transmitter = Transmitter;
           }
-          responseByteArray = _Transmitter.sendCommand(messageByteArray);
+          responseByteArray = _Transmitter?.sendCommand(messageByteArray);
         } else {
           throw new Error("Allowed only to run in nodejs runtime");
         }
       }
+      if (!responseByteArray) {
+        throw new Error("No response received from Transmitter");
+      }
       return new import_CommandDeserializer.CommandDeserializer(responseByteArray).deserialize();
     } catch (error) {
       throw error;
@@ -138,7 +154,7 @@ class Interpreter {
   }
   /**
    *
-   * @param {number[]} messageByteArray
+   * @param {Int8Array} messageByteArray
    * @returns {Command}
    */
   process(messageByteArray) {

package/dist/core/namespaceCache/NamespaceCache.cjs

@@ -22,7 +22,9 @@ __export(NamespaceCache_exports, {
 });
 module.exports = __toCommonJS(NamespaceCache_exports);
 class NamespaceCache {
+  /** @type {NamespaceCache | null} */
   static _instance = null;
+  /** @type {string[]} */
   namespaceCache = [];
   constructor() {
     if (NamespaceCache._instance === null) {
@@ -30,12 +32,22 @@ class NamespaceCache {
     }
     return NamespaceCache._instance;
   }
+  /**
+   * @param {string} namespaceRegex
+   */
   cacheNamespace(namespaceRegex) {
     this.namespaceCache.push(namespaceRegex);
   }
+  /**
+   * @returns {boolean}
+   */
   isNamespaceCacheEmpty() {
     return this.namespaceCache.length === 0;
   }
+  /**
+   * @param {string} typeToCheck
+   * @returns {boolean}
+   */
   isTypeAllowed(typeToCheck) {
     for (let pattern of this.namespaceCache) {
       if (new RegExp(pattern).test(typeToCheck.constructor.name)) {