javonet-nodejs-sdk 2.5.15 → 2.5.17

package/dist/core/delegatesCache/DelegatesCache.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 DelegatesCache_exports = {};
+__export(DelegatesCache_exports, {
+  delegatesCacheInstance: () => delegatesCacheInstance
+});
+module.exports = __toCommonJS(DelegatesCache_exports);
+var import_generateGuid = require("../../utils/guid/generateGuid.cjs");
+class DelegatesCache {
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Adds a delegate to the cache and returns its unique ID.
+   * @param {Function} delegateInstance - The delegate function to store.
+   * @returns {string} The unique ID for the delegate.
+   */
+  addDelegate(delegateInstance) {
+    const delegateId = (0, import_generateGuid.generateGUID)();
+    this.cache.set(delegateId, delegateInstance);
+    return delegateId;
+  }
+  /**
+   * Retrieves a delegate by its unique ID.
+   * @param {string} delegateId - The unique ID of the delegate.
+   * @returns {Function} The delegate function.
+   * @throws {Error} If the delegate is not found.
+   */
+  getDelegate(delegateId) {
+    const delegateInstance = this.cache.get(delegateId);
+    if (!delegateInstance) {
+      throw new Error("Delegate not found");
+    }
+    return delegateInstance;
+  }
+}
+const delegatesCacheInstance = new DelegatesCache();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  delegatesCacheInstance
+});

package/dist/core/handler/AbstractHandler.cjs

@@ -0,0 +1,60 @@
+"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 AbstractHandler_exports = {};
+__export(AbstractHandler_exports, {
+  AbstractHandler: () => AbstractHandler
+});
+module.exports = __toCommonJS(AbstractHandler_exports);
+var import_Command = require("../../utils/Command.cjs");
+class AbstractHandler {
+  handlers = [];
+  constructor() {
+    if (new.target === AbstractHandler) throw new TypeError("You cannot instantiate abstract class");
+  }
+  // eslint-disable-next-line no-unused-vars
+  process(command) {
+    throw new Error("process must be implemented");
+  }
+  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);
+      }
+    }
+  }
+  process_stack_trace(error, class_name) {
+    let stackTraceArray = error.stack.split("\n").map((frame) => frame.trim());
+    stackTraceArray.forEach((str, index) => {
+      if (str.includes(class_name)) {
+        stackTraceArray = stackTraceArray.slice(0, index).filter((s) => !s.includes(class_name));
+      }
+    });
+    error.stack = stackTraceArray.join(" \n ");
+    return error;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AbstractHandler
+});

package/dist/core/handler/ArrayGetItemHandler.cjs

@@ -0,0 +1,59 @@
+"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 ArrayGetItemHandler_exports = {};
+__export(ArrayGetItemHandler_exports, {
+  ArrayGetItemHandler: () => ArrayGetItemHandler
+});
+module.exports = __toCommonJS(ArrayGetItemHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class ArrayGetItemHandler extends import_AbstractHandler.AbstractHandler {
+  requiredParametersCount = 2;
+  constructor() {
+    super();
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Array Get Item parameters mismatch");
+      }
+      let array = command.payload[0];
+      let indexes;
+      if (Array.isArray(command.payload[1])) {
+        indexes = command.payload[1];
+      } else {
+        indexes = command.payload.slice(1);
+      }
+      if (indexes.length === 1) {
+        return array[indexes];
+      } else {
+        let array_copy = [...array];
+        for (let i = 0; i < indexes.length; i++) {
+          array_copy = array_copy[indexes[i]];
+        }
+        return array_copy;
+      }
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArrayGetItemHandler
+});

package/dist/core/handler/ArrayGetRankHandler.cjs

@@ -0,0 +1,50 @@
+"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 ArrayGetRankHandler_exports = {};
+__export(ArrayGetRankHandler_exports, {
+  ArrayGetRankHandler: () => ArrayGetRankHandler
+});
+module.exports = __toCommonJS(ArrayGetRankHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class ArrayGetRankHandler extends import_AbstractHandler.AbstractHandler {
+  requiredParametersCount = 1;
+  constructor() {
+    super();
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Array Get Rank parameters mismatch");
+      }
+      let array = command.payload[0];
+      let rank = 0;
+      while (Array.isArray(array)) {
+        rank = rank + 1;
+        array = array[0];
+      }
+      return rank;
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArrayGetRankHandler
+});

package/dist/core/handler/ArrayGetSizeHandler.cjs

@@ -0,0 +1,50 @@
+"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 ArrayGetSizeHandler_exports = {};
+__export(ArrayGetSizeHandler_exports, {
+  ArrayGetSizeHandler: () => ArrayGetSizeHandler
+});
+module.exports = __toCommonJS(ArrayGetSizeHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class ArrayGetSizeHandler extends import_AbstractHandler.AbstractHandler {
+  requiredParametersCount = 1;
+  constructor() {
+    super();
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Array Get Size parameters mismatch");
+      }
+      let array = command.payload[0];
+      let size = 1;
+      while (Array.isArray(array)) {
+        size = size * array.length;
+        array = array[0];
+      }
+      return size;
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArrayGetSizeHandler
+});

package/dist/core/handler/ArrayHandler.cjs

@@ -0,0 +1,41 @@
+"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 ArrayHandler_exports = {};
+__export(ArrayHandler_exports, {
+  ArrayHandler: () => ArrayHandler
+});
+module.exports = __toCommonJS(ArrayHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class ArrayHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+  }
+  process(command) {
+    try {
+      let processedArray = command.payload;
+      return processedArray;
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArrayHandler
+});

package/dist/core/handler/ArraySetItemHandler.cjs

@@ -0,0 +1,60 @@
+"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 ArraySetItemHandler_exports = {};
+__export(ArraySetItemHandler_exports, {
+  ArraySetItemHandler: () => ArraySetItemHandler
+});
+module.exports = __toCommonJS(ArraySetItemHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class ArraySetItemHandler extends import_AbstractHandler.AbstractHandler {
+  requiredParametersCount = 3;
+  constructor() {
+    super();
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Array Set Item parameters mismatch");
+      }
+      let array = command.payload[0];
+      let value = command.payload[2];
+      let indexes;
+      if (Array.isArray(command.payload[1])) {
+        indexes = command.payload[1];
+      } else {
+        indexes = [command.payload[1]];
+      }
+      if (indexes.length === 1) {
+        array[indexes] = value;
+      } else {
+        for (let i = 0; i < indexes.length - 1; i++) {
+          array = array[indexes[i]];
+        }
+        array[indexes[indexes.length - 1]] = value;
+      }
+      return 0;
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArraySetItemHandler
+});

package/dist/core/handler/CastingHandler.cjs

@@ -0,0 +1,34 @@
+"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 CastingHandler_exports = {};
+__export(CastingHandler_exports, {
+  CastingHandler: () => CastingHandler
+});
+module.exports = __toCommonJS(CastingHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class CastingHandler extends import_AbstractHandler.AbstractHandler {
+  // eslint-disable-next-line no-unused-vars
+  process(command) {
+    throw new Error(`Dynamically typed languages are not supporting casting`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CastingHandler
+});

package/dist/core/handler/ConvertTypeHandler.cjs

@@ -0,0 +1,53 @@
+"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 ConvertTypeHandler_exports = {};
+__export(ConvertTypeHandler_exports, {
+  ConvertTypeHandler: () => ConvertTypeHandler
+});
+module.exports = __toCommonJS(ConvertTypeHandler_exports);
+var import_TypesConverter = require("../../utils/nodejs/TypesConverter.cjs");
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class ConvertTypeHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+    this.requiredParametersCount = 1;
+  }
+  /**
+   * Processes the given command to convert JType to Type.
+   * @param {Object} command - The command to process.
+   * @returns {any} The converted type.
+   */
+  process(command) {
+    this.validateCommand(command);
+    return import_TypesConverter.TypesConverter.convertJTypeToType(command.payload[0]);
+  }
+  /**
+   * Validates the command to ensure it has enough parameters.
+   * @param {Object} command - The command to validate.
+   */
+  validateCommand(command) {
+    if (command.payload.length < this.requiredParametersCount) {
+      throw new Error("ConvertTypeHandler parameters mismatch");
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConvertTypeHandler
+});

package/dist/core/handler/CreateClassInstanceHandler.cjs

@@ -0,0 +1,60 @@
+"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 CreateClassInstanceHandler_exports = {};
+__export(CreateClassInstanceHandler_exports, {
+  CreateClassInstanceHandler: () => CreateClassInstanceHandler
+});
+module.exports = __toCommonJS(CreateClassInstanceHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class CreateClassInstanceHandler extends import_AbstractHandler.AbstractHandler {
+  requiredParametersCount = 1;
+  constructor() {
+    super();
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Create Class Instance parameters mismatch");
+      }
+      let clazz = command.payload[0];
+      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 message = `Method 'constructor' not found in class. Available methods:
+`;
+        methods.forEach((methodIter) => {
+          message += `${methodIter}
+`;
+        });
+        throw new Error(message);
+      } else {
+        return instance;
+      }
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreateClassInstanceHandler
+});

package/dist/core/handler/DestructReferenceHandler.cjs

@@ -0,0 +1,42 @@
+"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 DestructReferenceHandler_exports = {};
+__export(DestructReferenceHandler_exports, {
+  DestructReferenceHandler: () => DestructReferenceHandler
+});
+module.exports = __toCommonJS(DestructReferenceHandler_exports);
+var import_ReferencesCache = require("../referenceCache/ReferencesCache.cjs");
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class DestructReferenceHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+  }
+  process(command) {
+    try {
+      let cache = import_ReferencesCache.ReferencesCache.getInstance();
+      return cache.deleteReference(command.payload[0]);
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DestructReferenceHandler
+});

package/dist/core/handler/EnableNamespaceHandler.cjs

@@ -0,0 +1,56 @@
+"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 EnableNamespaceHandler_exports = {};
+__export(EnableNamespaceHandler_exports, {
+  EnableNamespaceHandler: () => EnableNamespaceHandler
+});
+module.exports = __toCommonJS(EnableNamespaceHandler_exports);
+var import_NamespaceCache = require("../namespaceCache/NamespaceCache.cjs");
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class EnableNamespaceHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+    this.requiredParametersCount = 1;
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error(this.constructor.name + " parameters mismatch");
+      }
+      const namespace_cache = new import_NamespaceCache.NamespaceCache();
+      for (let payload of command.payload) {
+        if (typeof payload === "string") {
+          namespace_cache.cacheNamespace(payload);
+        }
+        if (Array.isArray(payload)) {
+          for (let namespace_to_enable of payload) {
+            namespace_cache.cacheNamespace(namespace_to_enable);
+          }
+        }
+      }
+      return 0;
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EnableNamespaceHandler
+});

package/dist/core/handler/EnableTypeHandler.cjs

@@ -0,0 +1,56 @@
+"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 EnableTypeHandler_exports = {};
+__export(EnableTypeHandler_exports, {
+  EnableTypeHandler: () => EnableTypeHandler
+});
+module.exports = __toCommonJS(EnableTypeHandler_exports);
+var import_TypeCache = require("../typeCache/TypeCache.cjs");
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class EnableTypeHandler extends import_AbstractHandler.AbstractHandler {
+  requiredParametersCount = 1;
+  constructor() {
+    super();
+  }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Get Type parameters mismatch");
+      }
+      const typeCache = new import_TypeCache.TypeCache();
+      for (let payload of command.payload) {
+        if (typeof payload === "string") {
+          typeCache.cacheType(payload);
+        }
+        if (Array.isArray(payload)) {
+          for (let namespace_to_enable of payload) {
+            typeCache.cacheType(namespace_to_enable);
+          }
+        }
+      }
+      return 0;
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EnableTypeHandler
+});