@nsshunt/stsuxvue 1.0.53 → 1.0.55

package/dist/stsuxvue.mjs

@@ -4,6 +4,11 @@ import { defineComponent, defineAsyncComponent, ref, createElementBlock, openBlo
 import { Gauge, ObservabilitySocketIOSubscriber, ObservabilityRESTAPISubscriber, ObservabilitySubscriptionManager, SubscriptionTopic } from "@nsshunt/stsobservability";
 import { defaultLogger } from "@nsshunt/stsutils";
 import { io } from "socket.io-client";
+import "socket.io";
+import "ioredis";
+import require$$0$2 from "node:cluster";
+import require$$1$2 from "socket.io-adapter";
+import "@socket.io/redis-streams-adapter";
 var _estate = /* @__PURE__ */ ((_estate2) => {
   _estate2["IDLE"] = "idle";
   _estate2["STARTING"] = "starting";
@@ -311,7 +316,6 @@ const _sfc_main$8 = /* @__PURE__ */ defineComponent({
       legend: {
         show: false
       }
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
     };
     __expose({
       UpdateGraph
@@ -6009,9 +6013,9 @@ function createDOMPurify() {
     return DOMPurify;
   }
   let {
-    document
+    document: document2
   } = window2;
-  const originalDocument = document;
+  const originalDocument = document2;
   const currentScript = originalDocument.currentScript;
   const {
     DocumentFragment,
@@ -6031,9 +6035,9 @@ function createDOMPurify() {
   const getChildNodes = lookupGetter(ElementPrototype, "childNodes");
   const getParentNode = lookupGetter(ElementPrototype, "parentNode");
   if (typeof HTMLTemplateElement === "function") {
-    const template = document.createElement("template");
+    const template = document2.createElement("template");
     if (template.content && template.content.ownerDocument) {
-      document = template.content.ownerDocument;
+      document2 = template.content.ownerDocument;
     }
   }
   let trustedTypesPolicy;
@@ -6043,7 +6047,7 @@ function createDOMPurify() {
     createNodeIterator,
     createDocumentFragment,
     getElementsByTagName
-  } = document;
+  } = document2;
   const {
     importNode
   } = originalDocument;
@@ -6141,7 +6145,7 @@ function createDOMPurify() {
   const DEFAULT_PARSER_MEDIA_TYPE = "text/html";
   let transformCaseFunc = null;
   let CONFIG = null;
-  const formElement = document.createElement("form");
+  const formElement = document2.createElement("form");
   const isRegexOrFunction = function isRegexOrFunction2(testValue) {
     return testValue instanceof RegExp || testValue instanceof Function;
   };
@@ -6403,7 +6407,7 @@ function createDOMPurify() {
     }
     const body = doc.body || doc.documentElement;
     if (dirty && leadingWhitespace) {
-      body.insertBefore(document.createTextNode(leadingWhitespace), body.childNodes[0] || null);
+      body.insertBefore(document2.createTextNode(leadingWhitespace), body.childNodes[0] || null);
     }
     if (NAMESPACE === HTML_NAMESPACE) {
       return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? "html" : "body")[0];
@@ -6502,7 +6506,7 @@ function createDOMPurify() {
     return false;
   };
   const _isValidAttribute = function _isValidAttribute2(lcTag, lcName, value) {
-    if (SANITIZE_DOM && (lcName === "id" || lcName === "name") && (value in document || value in formElement)) {
+    if (SANITIZE_DOM && (lcName === "id" || lcName === "name") && (value in document2 || value in formElement)) {
       return false;
     }
     if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR2, lcName)) ;
@@ -6891,8 +6895,8 @@ const _sfc_main$5 = /* @__PURE__ */ defineComponent({
         return retVal;
       }, "") + "]";
     };
-    const convertMS = function(ms) {
-      let s = Math.floor(ms / 1e3);
+    const convertMS = function(ms2) {
+      let s = Math.floor(ms2 / 1e3);
       let m = Math.floor(s / 60);
       s = s % 60;
       let h = Math.floor(m / 60);
@@ -8338,16 +8342,16 @@ function requireAnsiStyles() {
   })(ansiStyles);
   return ansiStyles.exports;
 }
-var browser;
-var hasRequiredBrowser;
-function requireBrowser() {
-  if (hasRequiredBrowser) return browser;
-  hasRequiredBrowser = 1;
-  browser = {
+var browser$1;
+var hasRequiredBrowser$1;
+function requireBrowser$1() {
+  if (hasRequiredBrowser$1) return browser$1;
+  hasRequiredBrowser$1 = 1;
+  browser$1 = {
     stdout: false,
     stderr: false
   };
-  return browser;
+  return browser$1;
 }
 var util;
 var hasRequiredUtil;
@@ -8508,7 +8512,7 @@ function requireSource() {
   if (hasRequiredSource) return source;
   hasRequiredSource = 1;
   const ansiStyles2 = requireAnsiStyles();
-  const { stdout: stdoutColor, stderr: stderrColor } = requireBrowser();
+  const { stdout: stdoutColor, stderr: stderrColor } = requireBrowser$1();
   const {
     stringReplaceAll,
     stringEncaseCRLFWithFirstIndex
@@ -8819,8 +8823,8 @@ const _sfc_main$4 = /* @__PURE__ */ defineComponent({
         return "";
       }
     };
-    const convertMS = function(ms) {
-      let s = Math.floor(ms / 1e3);
+    const convertMS = function(ms2) {
+      let s = Math.floor(ms2 / 1e3);
       let m = Math.floor(s / 60);
       s = s % 60;
       let h = Math.floor(m / 60);
@@ -9992,50 +9996,99 @@ function v4(options, buf, offset) {
   return _v4(options);
 }
 const isNode = Object.prototype.toString.call(typeof process !== "undefined" ? process : 0) === "[object process]";
-class SocketIoClientHelper {
-  #options;
-  #sockets = {};
-  constructor(options) {
-    this.#options = options;
+class SocketIoClient {
+  #agentManager;
+  #logger;
+  #name;
+  #address;
+  #socketIoCustomPath;
+  #authToken;
+  #socket;
+  constructor(name) {
+    this.#name = name;
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  #LogDebugMessage(message) {
-    if (this.#options.logger) this.#options.logger.debug(message);
+  LogDebugMessage(message) {
+    if (this.#logger) this.#logger.debug(message);
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  #LogErrorMessage(message) {
-    if (this.#options.logger) this.#options.logger.error(message);
+  LogErrorMessage(message) {
+    if (this.#logger) this.#logger.error(message);
   }
-  get sockets() {
-    return this.#sockets;
+  get name() {
+    return this.#name;
   }
-  SetupClientSideSocket(name, address, socketIoCustomPath, onConnectCallBack, socketEventsCallBack, errorCallBack) {
-    this.sockets[name] = {
-      name,
-      address,
-      socket: null,
-      errorCallBack
-    };
-    this.#EstablishSocketConnect(name, socketIoCustomPath, onConnectCallBack, socketEventsCallBack);
-    return this.sockets[name].socket;
+  get agentManager() {
+    return this.#agentManager;
+  }
+  get logger() {
+    return this.#logger;
+  }
+  get address() {
+    return this.#address;
+  }
+  get authToken() {
+    return this.#authToken;
+  }
+  get socketIoCustomPath() {
+    return this.#socketIoCustomPath;
+  }
+  get socket() {
+    return this.#socket;
+  }
+  WithAddress(address) {
+    this.#address = address;
+    return this;
+  }
+  WithAuthToken(authToken) {
+    this.#authToken = authToken;
+    return this;
+  }
+  WithSocketIoCustomPath(socketIoCustomPath) {
+    this.#socketIoCustomPath = socketIoCustomPath;
+    return this;
+  }
+  WithLogger(logger) {
+    this.#logger = logger;
+    return this;
+  }
+  WithAgentManager(agentManager) {
+    this.#agentManager = agentManager;
+    return this;
+  }
+  SetupSocket() {
+    if (!this.#address) {
+      throw new Error(`SocketIoClientHelper:SetupSocket(): Error: [address not provided]`);
+    }
+    this.#EstablishSocketConnect();
+    return this;
   }
-  GetSocket(name) {
-    return this.sockets[name].socket;
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  ConnectCallBack(socket) {
   }
-  GetSocketDetail(name) {
-    return this.sockets[name];
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  SocketEventsCallBack(socket) {
   }
-  #EstablishSocketConnect(name, socketIoCustomPath, onConnectCallBack, socketEventsCallBack) {
-    const socketDetail = this.sockets[name];
-    if (socketDetail.socket !== null) {
-      if (socketDetail.socket.connected === true) {
-        socketDetail.socket.disconnect();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  ErrorCallBack(error) {
+  }
+  emit(ev, ...args) {
+    if (this.#socket) {
+      return this.#socket.emit(ev, ...args);
+    } else {
+      throw new Error("SocketIoClient:emit(): Error: [socket instance not defined.]");
+    }
+  }
+  #EstablishSocketConnect() {
+    if (this.#socket !== void 0) {
+      if (this.#socket.connected === true) {
+        this.#socket.disconnect();
       }
-      socketDetail.socket = null;
+      this.#socket = void 0;
       if (isNode) {
-        setTimeout(() => this.#EstablishSocketConnect(name, socketIoCustomPath, onConnectCallBack, socketEventsCallBack), 100).unref();
+        setTimeout(() => this.#EstablishSocketConnect(), 100).unref();
       } else {
-        setTimeout(() => this.#EstablishSocketConnect(name, socketIoCustomPath, onConnectCallBack, socketEventsCallBack), 100);
+        setTimeout(() => this.#EstablishSocketConnect(), 100);
       }
       return;
     }
@@ -10044,91 +10097,92 @@ class SocketIoClientHelper {
       socketOptions = {
         transports: ["websocket"]
       };
-      if (this.#options.agentManager) {
-        socketOptions.agent = this.#options.agentManager.GetAgent(socketDetail.address);
+      if (this.#agentManager) {
+        if (!this.#address) {
+          throw new Error(`SocketIoClientHelper:SetupSocket(): Error: [address not provided when using agentManager]`);
+        }
+        socketOptions.agent = this.#agentManager.GetAgent(this.#address);
       }
     } else {
       socketOptions = {
         transports: ["websocket"]
       };
     }
-    if (socketIoCustomPath && socketIoCustomPath.localeCompare("") !== 0) {
-      socketOptions.path = socketIoCustomPath;
+    if (this.#authToken) {
+      socketOptions.auth = (cb) => {
+        cb({
+          token: this.#authToken
+        });
+      };
     }
-    socketDetail.socket = io(socketDetail.address, socketOptions);
-    socketDetail.socket.io.on("error", (err) => {
-      this.#LogErrorMessage(`SocketIoClientHelper(): socketDetail.socket.io.on('error'): [${err}] Address: [${socketDetail.address}]`);
-    });
-    socketDetail.socket.io.on("reconnect_error", (err) => {
-      this.#LogErrorMessage(`SocketIoClientHelper(): socketDetail.socket.io.on('reconnect_error'): [${err}] Address: [${socketDetail.address}]`);
+    if (this.#socketIoCustomPath && this.#socketIoCustomPath.localeCompare("") !== 0) {
+      socketOptions.path = this.#socketIoCustomPath;
+    }
+    this.#socket = io(this.#address, socketOptions);
+    this.#socket.io.on("error", (err) => {
+      this.LogErrorMessage(`SocketIoClientHelper(): socketDetail.socket.io.on('error'): [${err}] Address: [${this.#address}]`);
     });
-    socketDetail.socket.io.on("reconnect", (attempt) => {
-      this.#LogErrorMessage(`SocketIoClientHelper(): socketDetail.socket.io.on('reconnect'): Number: [${attempt}] Address: [${socketDetail.address}]`);
+    this.#socket.io.on("reconnect_error", (err) => {
+      this.LogErrorMessage(`SocketIoClientHelper(): socketDetail.socket.io.on('reconnect_error'): [${err}] Address: [${this.#address}]`);
     });
-    socketDetail.socket.on("connect_error", (err) => {
-      this.#LogErrorMessage(`SocketIoClientHelper(): socketDetail.socket.on('connect_error'): [${err}] Address: [${socketDetail.address}]`);
+    this.#socket.on("connect_error", (err) => {
+      this.LogErrorMessage(`SocketIoClientHelper(): socketDetail.socket.on('connect_error'): [${err}] Address: [${this.#address}]`);
     });
-    socketDetail.socket.on("connect_timeout", () => {
-      this.#LogErrorMessage(`SocketIoClientHelper(): socketDetail.socket.on('connect_timeout') Address: [${socketDetail.address}]`);
+    this.#socket.io.on("reconnect", (attempt) => {
+      this.LogErrorMessage(`SocketIoClientHelper(): socketDetail.socket.io.on('reconnect'): Number: [${attempt}] Address: [${this.#address}]`);
     });
-    socketDetail.socket.on("connect", () => {
-      if (socketDetail.socket) {
-        this.#LogDebugMessage(`SocketIoClientHelper(): Socket: [${socketDetail.socket.id}]: connected, Address: [${socketDetail.address}]`);
-        if (onConnectCallBack) {
-          setTimeout(() => {
-            onConnectCallBack(socketDetail.socket);
-          }, 0);
-        }
-        if (socketEventsCallBack) {
-          socketEventsCallBack(socketDetail.socket);
-        }
+    this.#socket.on("connect", () => {
+      if (this.#socket) {
+        this.LogDebugMessage(`SocketIoClientHelper(): Socket: [${this.#socket.id}]: connected, Address: [${this.#address}]`);
+        setTimeout(() => {
+          this.ConnectCallBack(this.#socket);
+        }, 0);
+        this.SocketEventsCallBack(this.#socket);
       } else {
         const errorMessage = "SocketIoClientHelper(): Could not get socket object from socket.io, Address: [${socketDetail.address}]";
-        this.#LogErrorMessage(errorMessage);
-        socketDetail.errorCallBack(new Error(errorMessage));
+        this.LogErrorMessage(errorMessage);
+        this.ErrorCallBack(new Error(errorMessage));
       }
     });
-    socketDetail.socket.on("disconnect", (reason) => {
-      this.#LogDebugMessage("SocketIoClientHelper(): socket disconnect: " + reason);
+    this.#socket.on("disconnect", (reason) => {
+      this.LogDebugMessage("SocketIoClientHelper(): socket disconnect: " + reason);
       switch (reason) {
         case "io server disconnect":
           {
-            this.#LogDebugMessage("SocketIoClientHelper(): The server disconnected using disconnectSockets, i.e. normal safe shutdown from explicit disconnection by the server.");
-            this.#LogDebugMessage("SocketIoClientHelper(): The connection will be re-established when the server becomes available.");
-            const socketDetail2 = this.sockets[name];
-            socketDetail2.socket = null;
+            this.LogDebugMessage("SocketIoClientHelper(): The server disconnected using disconnectSockets, i.e. normal safe shutdown from explicit disconnection by the server.");
+            this.LogDebugMessage("SocketIoClientHelper(): The connection will be re-established when the server becomes available.");
+            this.#socket = void 0;
             if (isNode) {
-              if (this.#options.agentManager) {
-                this.#options.agentManager.ResetAgent();
+              if (this.#agentManager) {
+                this.#agentManager.ResetAgent();
               }
-              setTimeout(() => this.#EstablishSocketConnect(name, socketIoCustomPath, onConnectCallBack, socketEventsCallBack), 100).unref();
+              setTimeout(() => this.#EstablishSocketConnect(), 100).unref();
             } else {
-              setTimeout(() => this.#EstablishSocketConnect(name, socketIoCustomPath, onConnectCallBack, socketEventsCallBack), 100);
+              setTimeout(() => this.#EstablishSocketConnect(), 100);
             }
           }
           break;
         case "io client disconnect":
-          this.#LogDebugMessage("SocketIoClientHelper(): The client disconnected using disconnectSockets, i.e. normal safe disconnection from explicit disconnection by the client.");
-          this.#LogDebugMessage("SocketIoClientHelper(): The connection will not be re-established automatically.");
+          this.LogDebugMessage("SocketIoClientHelper(): The client disconnected using disconnectSockets, i.e. normal safe disconnection from explicit disconnection by the client.");
+          this.LogDebugMessage("SocketIoClientHelper(): The connection will not be re-established automatically.");
           break;
         case "transport close":
         case "ping timeout":
         case "transport error":
           {
-            this.#LogDebugMessage(`SocketIoClientHelper(): Server unexpectedly disconnected. Reason: [${reason}]`);
-            this.#LogDebugMessage("SocketIoClientHelper(): The connection will be re-established when the server becomes available.");
-            const socketDetail2 = this.sockets[name];
-            if (socketDetail2.socket) {
-              socketDetail2.socket.disconnect();
+            this.LogDebugMessage(`SocketIoClientHelper(): Server unexpectedly disconnected. Reason: [${reason}]`);
+            this.LogDebugMessage("SocketIoClientHelper(): The connection will be re-established when the server becomes available.");
+            if (this.#socket) {
+              this.#socket.disconnect();
             }
-            socketDetail2.socket = null;
+            this.#socket = void 0;
             if (isNode) {
-              if (this.#options.agentManager) {
-                this.#options.agentManager?.ResetAgent();
+              if (this.#agentManager) {
+                this.#agentManager?.ResetAgent();
               }
-              setTimeout(() => this.#EstablishSocketConnect(name, socketIoCustomPath, onConnectCallBack, socketEventsCallBack), 100).unref();
+              setTimeout(() => this.#EstablishSocketConnect(), 100).unref();
             } else {
-              setTimeout(() => this.#EstablishSocketConnect(name, socketIoCustomPath, onConnectCallBack, socketEventsCallBack), 100);
+              setTimeout(() => this.#EstablishSocketConnect(), 100);
             }
           }
           break;
@@ -10136,6 +10190,563 @@ class SocketIoClientHelper {
     });
   }
 }
+var dist = {};
+var browser = { exports: {} };
+var ms;
+var hasRequiredMs;
+function requireMs() {
+  if (hasRequiredMs) return ms;
+  hasRequiredMs = 1;
+  var s = 1e3;
+  var m = s * 60;
+  var h = m * 60;
+  var d = h * 24;
+  var w = d * 7;
+  var y = d * 365.25;
+  ms = function(val, options) {
+    options = options || {};
+    var type = typeof val;
+    if (type === "string" && val.length > 0) {
+      return parse(val);
+    } else if (type === "number" && isFinite(val)) {
+      return options.long ? fmtLong(val) : fmtShort(val);
+    }
+    throw new Error(
+      "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+    );
+  };
+  function parse(str) {
+    str = String(str);
+    if (str.length > 100) {
+      return;
+    }
+    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+      str
+    );
+    if (!match) {
+      return;
+    }
+    var n = parseFloat(match[1]);
+    var type = (match[2] || "ms").toLowerCase();
+    switch (type) {
+      case "years":
+      case "year":
+      case "yrs":
+      case "yr":
+      case "y":
+        return n * y;
+      case "weeks":
+      case "week":
+      case "w":
+        return n * w;
+      case "days":
+      case "day":
+      case "d":
+        return n * d;
+      case "hours":
+      case "hour":
+      case "hrs":
+      case "hr":
+      case "h":
+        return n * h;
+      case "minutes":
+      case "minute":
+      case "mins":
+      case "min":
+      case "m":
+        return n * m;
+      case "seconds":
+      case "second":
+      case "secs":
+      case "sec":
+      case "s":
+        return n * s;
+      case "milliseconds":
+      case "millisecond":
+      case "msecs":
+      case "msec":
+      case "ms":
+        return n;
+      default:
+        return void 0;
+    }
+  }
+  function fmtShort(ms2) {
+    var msAbs = Math.abs(ms2);
+    if (msAbs >= d) {
+      return Math.round(ms2 / d) + "d";
+    }
+    if (msAbs >= h) {
+      return Math.round(ms2 / h) + "h";
+    }
+    if (msAbs >= m) {
+      return Math.round(ms2 / m) + "m";
+    }
+    if (msAbs >= s) {
+      return Math.round(ms2 / s) + "s";
+    }
+    return ms2 + "ms";
+  }
+  function fmtLong(ms2) {
+    var msAbs = Math.abs(ms2);
+    if (msAbs >= d) {
+      return plural(ms2, msAbs, d, "day");
+    }
+    if (msAbs >= h) {
+      return plural(ms2, msAbs, h, "hour");
+    }
+    if (msAbs >= m) {
+      return plural(ms2, msAbs, m, "minute");
+    }
+    if (msAbs >= s) {
+      return plural(ms2, msAbs, s, "second");
+    }
+    return ms2 + " ms";
+  }
+  function plural(ms2, msAbs, n, name) {
+    var isPlural = msAbs >= n * 1.5;
+    return Math.round(ms2 / n) + " " + name + (isPlural ? "s" : "");
+  }
+  return ms;
+}
+var common;
+var hasRequiredCommon;
+function requireCommon() {
+  if (hasRequiredCommon) return common;
+  hasRequiredCommon = 1;
+  function setup(env) {
+    createDebug.debug = createDebug;
+    createDebug.default = createDebug;
+    createDebug.coerce = coerce;
+    createDebug.disable = disable;
+    createDebug.enable = enable;
+    createDebug.enabled = enabled;
+    createDebug.humanize = requireMs();
+    createDebug.destroy = destroy;
+    Object.keys(env).forEach((key) => {
+      createDebug[key] = env[key];
+    });
+    createDebug.names = [];
+    createDebug.skips = [];
+    createDebug.formatters = {};
+    function selectColor(namespace) {
+      let hash = 0;
+      for (let i = 0; i < namespace.length; i++) {
+        hash = (hash << 5) - hash + namespace.charCodeAt(i);
+        hash |= 0;
+      }
+      return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+    }
+    createDebug.selectColor = selectColor;
+    function createDebug(namespace) {
+      let prevTime;
+      let enableOverride = null;
+      let namespacesCache;
+      let enabledCache;
+      function debug(...args) {
+        if (!debug.enabled) {
+          return;
+        }
+        const self = debug;
+        const curr = Number(/* @__PURE__ */ new Date());
+        const ms2 = curr - (prevTime || curr);
+        self.diff = ms2;
+        self.prev = prevTime;
+        self.curr = curr;
+        prevTime = curr;
+        args[0] = createDebug.coerce(args[0]);
+        if (typeof args[0] !== "string") {
+          args.unshift("%O");
+        }
+        let index = 0;
+        args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+          if (match === "%%") {
+            return "%";
+          }
+          index++;
+          const formatter = createDebug.formatters[format];
+          if (typeof formatter === "function") {
+            const val = args[index];
+            match = formatter.call(self, val);
+            args.splice(index, 1);
+            index--;
+          }
+          return match;
+        });
+        createDebug.formatArgs.call(self, args);
+        const logFn = self.log || createDebug.log;
+        logFn.apply(self, args);
+      }
+      debug.namespace = namespace;
+      debug.useColors = createDebug.useColors();
+      debug.color = createDebug.selectColor(namespace);
+      debug.extend = extend;
+      debug.destroy = createDebug.destroy;
+      Object.defineProperty(debug, "enabled", {
+        enumerable: true,
+        configurable: false,
+        get: () => {
+          if (enableOverride !== null) {
+            return enableOverride;
+          }
+          if (namespacesCache !== createDebug.namespaces) {
+            namespacesCache = createDebug.namespaces;
+            enabledCache = createDebug.enabled(namespace);
+          }
+          return enabledCache;
+        },
+        set: (v) => {
+          enableOverride = v;
+        }
+      });
+      if (typeof createDebug.init === "function") {
+        createDebug.init(debug);
+      }
+      return debug;
+    }
+    function extend(namespace, delimiter) {
+      const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+      newDebug.log = this.log;
+      return newDebug;
+    }
+    function enable(namespaces) {
+      createDebug.save(namespaces);
+      createDebug.namespaces = namespaces;
+      createDebug.names = [];
+      createDebug.skips = [];
+      const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+      for (const ns of split) {
+        if (ns[0] === "-") {
+          createDebug.skips.push(ns.slice(1));
+        } else {
+          createDebug.names.push(ns);
+        }
+      }
+    }
+    function matchesTemplate(search, template) {
+      let searchIndex = 0;
+      let templateIndex = 0;
+      let starIndex = -1;
+      let matchIndex = 0;
+      while (searchIndex < search.length) {
+        if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+          if (template[templateIndex] === "*") {
+            starIndex = templateIndex;
+            matchIndex = searchIndex;
+            templateIndex++;
+          } else {
+            searchIndex++;
+            templateIndex++;
+          }
+        } else if (starIndex !== -1) {
+          templateIndex = starIndex + 1;
+          matchIndex++;
+          searchIndex = matchIndex;
+        } else {
+          return false;
+        }
+      }
+      while (templateIndex < template.length && template[templateIndex] === "*") {
+        templateIndex++;
+      }
+      return templateIndex === template.length;
+    }
+    function disable() {
+      const namespaces = [
+        ...createDebug.names,
+        ...createDebug.skips.map((namespace) => "-" + namespace)
+      ].join(",");
+      createDebug.enable("");
+      return namespaces;
+    }
+    function enabled(name) {
+      for (const skip of createDebug.skips) {
+        if (matchesTemplate(name, skip)) {
+          return false;
+        }
+      }
+      for (const ns of createDebug.names) {
+        if (matchesTemplate(name, ns)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function coerce(val) {
+      if (val instanceof Error) {
+        return val.stack || val.message;
+      }
+      return val;
+    }
+    function destroy() {
+      console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+    }
+    createDebug.enable(createDebug.load());
+    return createDebug;
+  }
+  common = setup;
+  return common;
+}
+var hasRequiredBrowser;
+function requireBrowser() {
+  if (hasRequiredBrowser) return browser.exports;
+  hasRequiredBrowser = 1;
+  (function(module, exports) {
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.storage = localstorage();
+    exports.destroy = /* @__PURE__ */ (() => {
+      let warned = false;
+      return () => {
+        if (!warned) {
+          warned = true;
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+      };
+    })();
+    exports.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+        return true;
+      }
+      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+      }
+      let m;
+      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    function formatArgs(args) {
+      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+      if (!this.useColors) {
+        return;
+      }
+      const c = "color: " + this.color;
+      args.splice(1, 0, c, "color: inherit");
+      let index = 0;
+      let lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, (match) => {
+        if (match === "%%") {
+          return;
+        }
+        index++;
+        if (match === "%c") {
+          lastC = index;
+        }
+      });
+      args.splice(lastC, 0, c);
+    }
+    exports.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports.storage.setItem("debug", namespaces);
+        } else {
+          exports.storage.removeItem("debug");
+        }
+      } catch (error) {
+      }
+    }
+    function load() {
+      let r;
+      try {
+        r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
+      } catch (error) {
+      }
+      if (!r && typeof process !== "undefined" && "env" in process) {
+        r = process.env.DEBUG;
+      }
+      return r;
+    }
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error) {
+      }
+    }
+    module.exports = requireCommon()(exports);
+    const { formatters } = module.exports;
+    formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (error) {
+        return "[UnexpectedJSONParseError]: " + error.message;
+      }
+    };
+  })(browser, browser.exports);
+  return browser.exports;
+}
+var hasRequiredDist;
+function requireDist() {
+  if (hasRequiredDist) return dist;
+  hasRequiredDist = 1;
+  var __importDefault = dist && dist.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+  };
+  Object.defineProperty(dist, "__esModule", { value: true });
+  dist.NodeClusterAdapter = void 0;
+  dist.createAdapter = createAdapter2;
+  dist.setupPrimary = setupPrimary;
+  const node_cluster_1 = __importDefault(require$$0$2);
+  const socket_io_adapter_1 = require$$1$2;
+  const debug_1 = __importDefault(requireBrowser());
+  const debug = (0, debug_1.default)("socket.io-cluster-adapter");
+  const MESSAGE_SOURCE = "_sio_adapter";
+  const hasOwnProperty = Object.prototype.hasOwnProperty;
+  function ignoreError() {
+  }
+  function createAdapter2(opts = {}) {
+    return function(nsp) {
+      return new NodeClusterAdapter(nsp, opts);
+    };
+  }
+  class NodeClusterAdapter extends socket_io_adapter_1.ClusterAdapterWithHeartbeat {
+    constructor(nsp, opts = {}) {
+      super(nsp, opts);
+      process.on("message", (message) => {
+        const isValidSource = (message === null || message === void 0 ? void 0 : message.source) === MESSAGE_SOURCE;
+        if (!isValidSource) {
+          debug("[%s] ignore unknown source", this.uid);
+          return;
+        }
+        if (message.nsp !== this.nsp.name) {
+          debug("[%s] ignore other namespace", this.uid);
+          return;
+        }
+        this.onMessage(message);
+      });
+      this.init();
+    }
+    doPublish(message) {
+      message.source = MESSAGE_SOURCE;
+      process.send(message, null, {}, ignoreError);
+      return Promise.resolve("");
+    }
+    doPublishResponse(requesterUid, response) {
+      response.source = MESSAGE_SOURCE;
+      response.requesterUid = requesterUid;
+      process.send(response, null, {}, ignoreError);
+      return Promise.resolve();
+    }
+  }
+  dist.NodeClusterAdapter = NodeClusterAdapter;
+  const UIDS = /* @__PURE__ */ Symbol("uids");
+  function setupPrimary() {
+    node_cluster_1.default.on("message", (worker, message) => {
+      var _a;
+      const isValidSource = (message === null || message === void 0 ? void 0 : message.source) === MESSAGE_SOURCE;
+      if (!isValidSource) {
+        return;
+      }
+      worker[UIDS] = worker[UIDS] || /* @__PURE__ */ new Set();
+      worker[UIDS].add(message.uid);
+      switch (message.type) {
+        case socket_io_adapter_1.MessageType.FETCH_SOCKETS_RESPONSE:
+        case socket_io_adapter_1.MessageType.SERVER_SIDE_EMIT_RESPONSE:
+          const requesterUid = message.requesterUid;
+          for (const workerId in node_cluster_1.default.workers) {
+            if (hasOwnProperty.call(node_cluster_1.default.workers, workerId) && ((_a = node_cluster_1.default.workers[workerId][UIDS]) === null || _a === void 0 ? void 0 : _a.has(requesterUid))) {
+              node_cluster_1.default.workers[workerId].send(message, null, ignoreError);
+              break;
+            }
+          }
+          break;
+        default:
+          const emitterIdAsString = String(worker.id);
+          for (const workerId in node_cluster_1.default.workers) {
+            if (hasOwnProperty.call(node_cluster_1.default.workers, workerId) && workerId !== emitterIdAsString) {
+              node_cluster_1.default.workers[workerId].send(message, null, ignoreError);
+            }
+          }
+      }
+    });
+  }
+  return dist;
+}
+requireDist();
 var tinyEmitter = { exports: {} };
 var hasRequiredTinyEmitter;
 function requireTinyEmitter() {
@@ -10191,7 +10802,7 @@ function requireTinyEmitter() {
 }
 var tinyEmitterExports = requireTinyEmitter();
 const SOCKET_NAMESPACE = "stsinstrumentmanager/stsmonitor";
-class ObservabilitySubscriberManager {
+class ObservabilitySubscriberManager extends SocketIoClient {
   #socket = null;
   #observabilitySocketIOSubscriber = null;
   #logger;
@@ -10203,6 +10814,7 @@ class ObservabilitySubscriberManager {
   #tinyEmitter;
   #id;
   constructor(options) {
+    super("STSVueTilsTester");
     this.#id = v4();
     this.#options = options;
     this.#modelId = options.modelId;
@@ -10350,40 +10962,54 @@ class ObservabilitySubscriberManager {
           resolve(true);
         };
         this.#tinyEmitter.on("connected", onConnected);
-        this.#SetupSocketIO();
+        this.WithAddress(`${this.#options.instrumentManagerEndpoint}:${this.#options.instrumentManagerPort}/${SOCKET_NAMESPACE}/`).WithLogger(this.#logger).SetupSocket();
       } else {
         this.#SetupObservabilitySubscriber();
         resolve(true);
       }
     });
   };
-  #SetupSocketIO = () => {
-    const socketUtils = new SocketIoClientHelper({});
-    this.#socket = socketUtils.SetupClientSideSocket(
-      "STSVueTilsTester",
-      `${this.#options.instrumentManagerEndpoint}:${this.#options.instrumentManagerPort}/${SOCKET_NAMESPACE}/`,
-      "",
-      // use default /socket.io/ path
-      this.#SocketConnect,
-      // Connected call back
-      this.#ProcessSocketEvents,
-      // Custom Events
-      this.#ProcessSocketError
-      // Handle socket errors
-    );
-  };
-  #SocketConnect = (socket) => {
+  ConnectCallBack(socket) {
     defaultLogger.debug(chalk.magenta(`SocketIOConnect(): Socket ID: [${socket.id}]`));
     if (this.#observabilitySubscriptionManager === null) {
       this.#SetupObservabilitySubscriber();
     }
     this.#SocketIOConnect(socket);
-  };
-  #ProcessSocketError = (error) => {
+  }
+  ErrorCallBack(error) {
     defaultLogger.error(chalk.red(`SetupClientSideSocket error callback: [${error}]`));
-  };
-  #ProcessSocketEvents = (socket) => {
-  };
+  }
+  SocketEventsCallBack(socket) {
+  }
+  /*
+      #SetupSocketIO = () => {
+          const socketUtils = new SocketIoClientHelper({});
+  
+          this.#socket = socketUtils.SetupClientSideSocket('STSVueTilsTester', 
+              `${this.#options.instrumentManagerEndpoint}:${this.#options.instrumentManagerPort}/${SOCKET_NAMESPACE}/`,
+              '', // use default /socket.io/ path
+              this.#SocketConnect as any, // Connected call back
+              this.#ProcessSocketEvents as any, // Custom Events
+              this.#ProcessSocketError // Handle socket errors
+          ) as any;
+      }
+  
+      #SocketConnect = (socket: Socket) => {
+          defaultLogger.debug(chalk.magenta(`SocketIOConnect(): Socket ID: [${socket.id}]`));
+          if (this.#observabilitySubscriptionManager === null) {
+              this.#SetupObservabilitySubscriber();
+          }
+          this.#SocketIOConnect(socket);
+      }
+      
+      #ProcessSocketError = (error: any) => {
+          defaultLogger.error(chalk.red(`SetupClientSideSocket error callback: [${error}]`))
+      }
+      
+      #ProcessSocketEvents = (socket: Socket) => {
+      
+      }
+      */
 }
 const _hoisted_1$1 = { class: "d-flex flex-wrap justify-space-between" };
 const _sfc_main$1 = /* @__PURE__ */ defineComponent({