@nsshunt/stsvueutils 1.0.16 → 1.0.18

package/dist/stsvueutils.mjs

@@ -0,0 +1,681 @@
+var me = Object.defineProperty;
+var he = (s, e, t) => e in s ? me(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var c = (s, e, t) => (he(s, typeof e != "symbol" ? e + "" : e, t), t), x = (s, e, t) => {
+  if (!e.has(s))
+    throw TypeError("Cannot " + t);
+};
+var n = (s, e, t) => (x(s, e, "read from private field"), t ? t.call(s) : e.get(s)), l = (s, e, t) => {
+  if (e.has(s))
+    throw TypeError("Cannot add the same private member more than once");
+  e instanceof WeakSet ? e.add(s) : e.set(s, t);
+}, g = (s, e, t, r) => (x(s, e, "write to private field"), r ? r.call(s, t) : e.set(s, t), t), Z = (s, e, t, r) => ({
+  set _(o) {
+    g(s, e, o, t);
+  },
+  get _() {
+    return n(s, e, r);
+  }
+}), ee = (s, e, t) => (x(s, e, "access private method"), t);
+import { inject as ue } from "vue";
+import Y from "debug";
+import { STSInstrumentControllerPluginKey as A, GetSTSInstrumentController as fe, PublishMessageCommands as h, GetSTSInstrumentControllerPluginKey as Se } from "@nsshunt/stspublisherserver";
+import { Gauge as de } from "@nsshunt/stsinstrumentation";
+import { ModelDelimeter as te } from "@nsshunt/stsmodels";
+import { defineStore as ye } from "pinia";
+import { Sleep as ke } from "@nsshunt/stsutils";
+const oe = Symbol("storage"), ne = Symbol("emitter"), ie = Symbol("workerManager");
+var ae = {}, Te = {
+  get exports() {
+    return ae;
+  },
+  set exports(s) {
+    ae = s;
+  }
+};
+function ge() {
+}
+ge.prototype = {
+  on: function(s, e, t) {
+    var r = this.e || (this.e = {});
+    return (r[s] || (r[s] = [])).push({
+      fn: e,
+      ctx: t
+    }), this;
+  },
+  once: function(s, e, t) {
+    var r = this;
+    function o() {
+      r.off(s, o), e.apply(t, arguments);
+    }
+    return o._ = e, this.on(s, o, t);
+  },
+  emit: function(s) {
+    var e = [].slice.call(arguments, 1), t = ((this.e || (this.e = {}))[s] || []).slice(), r = 0, o = t.length;
+    for (r; r < o; r++)
+      t[r].fn.apply(t[r].ctx, e);
+    return this;
+  },
+  off: function(s, e) {
+    var t = this.e || (this.e = {}), r = t[s], o = [];
+    if (r && e)
+      for (var i = 0, a = r.length; i < a; i++)
+        r[i].fn !== e && r[i].fn._ !== e && o.push(r[i]);
+    return o.length ? t[s] = o : delete t[s], this;
+  }
+};
+Te.exports = ge;
+var Re = ae.TinyEmitter = ge;
+const Je = () => ue(ne), He = {
+  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+  install: (s) => {
+    const e = new Re();
+    s.config.globalProperties.$sts || (s.config.globalProperties.$sts = {}), s.config.globalProperties.$sts[ne] = e, s.provide(ne, e);
+  }
+};
+/*! js-cookie v3.0.1 | MIT */
+function _(s) {
+  for (var e = 1; e < arguments.length; e++) {
+    var t = arguments[e];
+    for (var r in t)
+      s[r] = t[r];
+  }
+  return s;
+}
+var We = {
+  read: function(s) {
+    return s[0] === '"' && (s = s.slice(1, -1)), s.replace(/(%[\dA-F]{2})+/gi, decodeURIComponent);
+  },
+  write: function(s) {
+    return encodeURIComponent(s).replace(
+      /%(2[346BF]|3[AC-F]|40|5[BDE]|60|7[BCD])/g,
+      decodeURIComponent
+    );
+  }
+};
+function le(s, e) {
+  function t(o, i, a) {
+    if (!(typeof document > "u")) {
+      a = _({}, e, a), typeof a.expires == "number" && (a.expires = new Date(Date.now() + a.expires * 864e5)), a.expires && (a.expires = a.expires.toUTCString()), o = encodeURIComponent(o).replace(/%(2[346B]|5E|60|7C)/g, decodeURIComponent).replace(/[()]/g, escape);
+      var u = "";
+      for (var m in a)
+        a[m] && (u += "; " + m, a[m] !== !0 && (u += "=" + a[m].split(";")[0]));
+      return document.cookie = o + "=" + s.write(i, o) + u;
+    }
+  }
+  function r(o) {
+    if (!(typeof document > "u" || arguments.length && !o)) {
+      for (var i = document.cookie ? document.cookie.split("; ") : [], a = {}, u = 0; u < i.length; u++) {
+        var m = i[u].split("="), pe = m.slice(1).join("=");
+        try {
+          var X = decodeURIComponent(m[0]);
+          if (a[X] = s.read(pe, X), o === X)
+            break;
+        } catch {
+        }
+      }
+      return o ? a[o] : a;
+    }
+  }
+  return Object.create(
+    {
+      set: t,
+      get: r,
+      remove: function(o, i) {
+        t(
+          o,
+          "",
+          _({}, i, {
+            expires: -1
+          })
+        );
+      },
+      withAttributes: function(o) {
+        return le(this.converter, _({}, this.attributes, o));
+      },
+      withConverter: function(o) {
+        return le(_({}, this.converter, o), this.attributes);
+      }
+    },
+    {
+      attributes: { value: Object.freeze(e) },
+      converter: { value: Object.freeze(s) }
+    }
+  );
+}
+var se = le(We, { path: "/" });
+const Q = Y(`proc:${process.pid}:storage.ts`);
+let p = "_ststra_";
+var Pe = /* @__PURE__ */ ((s) => (s.LOCAL_STORAGE = "LocalStorage", s.SESSION_STORAGE = "SessionStorage", s.COOKIE_STORAGE = "CookieStorage", s.MEMORY_STORAGE = "MemoryStorage", s))(Pe || {});
+class ve {
+  constructor() {
+    c(this, "get", (e) => {
+      const t = se.get(p + e);
+      return t ? JSON.parse(t) : null;
+    });
+    c(this, "set", (e, t, r = {}) => {
+      let o = {};
+      window.location.protocol === "https:" && (o = {
+        secure: !0,
+        sameSite: "none"
+      }), r && r.daysUntilExpire ? o.expires = r.daysUntilExpire : o.expires = 1, Q(`CookieStorage.set: key: ${e}, value: [${t}]`), se.set(p + e, JSON.stringify(t), o);
+    });
+    c(this, "remove", (e) => {
+      se.remove(p + e);
+    });
+  }
+}
+class Oe {
+  constructor() {
+    c(this, "get", (e) => {
+      const t = sessionStorage.getItem(p + e);
+      return t ? JSON.parse(t) : null;
+    });
+    c(this, "set", (e, t) => {
+      Q(`SessionStorage.set: key: ${e}, value: [${t}]`), sessionStorage.setItem(p + e, JSON.stringify(t));
+    });
+    c(this, "remove", (e) => {
+      sessionStorage.removeItem(p + e);
+    });
+  }
+}
+class $e {
+  constructor() {
+    c(this, "get", (e) => {
+      const t = localStorage.getItem(p + e);
+      return t ? JSON.parse(t) : null;
+    });
+    c(this, "set", (e, t) => {
+      Q(`LocalStorage.set: key: ${e}, value: [${t}]`), localStorage.setItem(p + e, JSON.stringify(t));
+    });
+    c(this, "remove", (e) => {
+      localStorage.removeItem(p + e);
+    });
+  }
+}
+var v;
+class Ie {
+  constructor() {
+    l(this, v, {});
+    c(this, "get", (e) => {
+      const t = n(this, v)[p + e];
+      return t || null;
+    });
+    c(this, "set", (e, t) => {
+      Q(`MemoryStorage.set: key: ${e}, value: [${t}]`), n(this, v)[p + e] = t;
+    });
+    c(this, "remove", (e) => {
+      delete n(this, v)[p + e];
+    });
+  }
+}
+v = new WeakMap();
+var y;
+class Me {
+  constructor(e) {
+    l(this, y, void 0);
+    switch (e.usePrefix === !1 && (p = ""), e.clientStorageType) {
+      case "SessionStorage":
+        g(this, y, new Oe());
+        break;
+      case "LocalStorage":
+        g(this, y, new $e());
+        break;
+      case "CookieStorage":
+        g(this, y, new ve());
+        break;
+      case "MemoryStorage":
+        g(this, y, new Ie());
+        break;
+      default:
+        throw new Error(`Unknown [${e.clientStorageType}] storage type.`);
+    }
+  }
+  GetStorage() {
+    return n(this, y);
+  }
+}
+y = new WeakMap();
+const Le = () => ue(oe), Fe = {
+  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+  install: (s, e) => {
+    const r = new Me({ clientStorageType: e.clientStorageType, usePrefix: !0 }).GetStorage();
+    s.config.globalProperties.$sts || (s.config.globalProperties.$sts = {}), s.config.globalProperties.$sts[oe] = r, s.provide(oe, r);
+  }
+}, re = ye("__sts__TelemetryStore", {
+  // State
+  // https://pinia.vuejs.org/core-concepts/state.html
+  state: () => ({
+    workers: {}
+  }),
+  // Getters
+  // https://pinia.vuejs.org/core-concepts/getters.html
+  // Actions
+  // https://pinia.vuejs.org/core-concepts/actions.html
+  actions: {
+    RemoveWorker(s) {
+      delete this.workers[s.id];
+    },
+    RemoveRunner(s, e) {
+      const t = this.workers[s.id];
+      t && t.runners && delete t.runners[e.id];
+    },
+    Update(s, e) {
+      this.workers[s.id] || (this.workers[s.id] = {
+        id: s.id,
+        state: s.state,
+        primaryThreadWorkerOptions: { ...s.primaryThreadWorkerOptions },
+        workerThreadWorkerOptions: { ...s.workerThreadWorkerOptions },
+        runners: {}
+      });
+      const t = this.workers[s.id];
+      if (t.runners)
+        if (t.runners[e.id]) {
+          const r = t.runners[e.id];
+          r.instrumentData = { ...e.instrumentData };
+        } else {
+          const r = {
+            id: e.id,
+            asyncRunnerContext: { ...e.asyncRunnerContext },
+            options: { ...e.options },
+            state: e.state,
+            instrumentData: { ...e.instrumentData }
+          };
+          t.runners[r.id] = r;
+        }
+    }
+  }
+});
+var C = /* @__PURE__ */ ((s) => (s.created = "created", s.running = "running", s.stopped = "stopped", s.paused = "paused", s.error = "error", s))(C || {}), q = /* @__PURE__ */ ((s) => (s.starting = "starting", s.started = "started", s.stopped = "stopped", s))(q || {});
+const P = Y(`proc:${process.pid}:workerManager`);
+var O, k, j, T, R, D, N, ce, E, J, H, W, L, $, F;
+class be {
+  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+  constructor(e, t) {
+    l(this, N);
+    //#agentSession: string = null;
+    l(this, O, {});
+    l(this, k, 0);
+    l(this, j, 0);
+    l(this, T, void 0);
+    l(this, R, void 0);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    l(this, D, void 0);
+    c(this, "AddWorker", async (e) => {
+      let t;
+      e ? t = e : t = n(this, T).workerFactory;
+      const r = {
+        id: Z(this, j)._++,
+        // uuidv4()
+        worker: t.createWorkerThreadWorker(),
+        primaryWorker: t.createPrimaryThreadWorker(n(this, D), t.primaryThreadWorkerOptions),
+        state: q.starting,
+        workerThreadWorkerOptions: t.workerThreadWorkerOptions,
+        primaryThreadWorkerOptions: t.primaryThreadWorkerOptions,
+        runnersEx: {},
+        AddRunner: (u) => this.AddRunnerToWorker(r, u),
+        StopRunner: (u) => n(this, $).call(this, r, u),
+        Stop: async () => n(this, F).call(this, r)
+      };
+      console.log(`Adding worker: [${r.id}]`), r.worker.onmessage = function(u) {
+        console.log(u.data);
+      }, r.worker.onerror = function(u) {
+        console.log(u);
+      };
+      const {
+        port1: o,
+        // process message port
+        port2: i
+        // collector message port
+      } = new MessageChannel(), a = o;
+      return console.log(`STSWorkerManager::AddWorker::workerThreadWorkerOptions: [${JSON.stringify(r.workerThreadWorkerOptions)}]`), n(this, W).call(this, r, h.MessagePort, {
+        port: i,
+        //applicationStoreState: stateCopy,
+        options: { ...r.workerThreadWorkerOptions }
+      }, i), a.onmessage = async (u) => {
+        const m = u.data;
+        switch (m.command) {
+          case h.MessagePortResponse:
+            r.state = q.started;
+            break;
+          case h.InstrumentTelemetry:
+            n(this, J).call(this, r, m.payload);
+            break;
+          default:
+            r.primaryWorker.ProcessMessageFromWorker(a, m);
+        }
+      }, n(this, O)[r.id] = r, console.log(`Added worker: [${r.id}]`), r;
+    });
+    c(this, "AddRunnerToWorker", (e, t) => {
+      const r = n(this, H).call(this, e, t);
+      return e.runnersEx[r.id] = r, n(this, E).call(this, e, r), r;
+    });
+    l(this, E, (e, t) => {
+      const r = {
+        runner: ee(this, N, ce).call(this, t)
+      };
+      n(this, W).call(this, e, h.Add, r);
+    });
+    l(this, J, (e, t) => {
+      const r = re(), { runner: o } = t;
+      if (e.runnersEx[o.id]) {
+        const i = e.runnersEx[o.id];
+        let a = !1;
+        i.instrumentData.count = o.instrumentData.count, i.instrumentData.velocity = o.instrumentData.velocity, o.instrumentData.message ? i.instrumentData.message = [...o.instrumentData.message] : i.instrumentData.message = [], o.instrumentData.message && (o.instrumentData.message.forEach((u) => {
+          i.publishInstrumentController.LogEx(u);
+        }), a = !0), o.instrumentData.count && (i.publishInstrumentController.UpdateInstrument(de.REQUEST_COUNT_GAUGE, {
+          val: i.instrumentData.count
+        }), i.publishInstrumentController.UpdateInstrument(de.VELOCITY_GAUGE, {
+          Inc: i.instrumentData.velocity
+        }), a = !0), a && r.Update(e, i);
+      }
+    });
+    l(this, H, (e, t) => {
+      Z(this, k)._++;
+      const r = {
+        nid: `${e.workerThreadWorkerOptions.hostName}${te.COMPONENT_SEPERATOR}${e.workerThreadWorkerOptions.agentId}-${e.workerThreadWorkerOptions.userAgent}${te.NID_SEPERATOR}worker${e.id}${te.SEPERATOR}${n(this, k)}`,
+        id: n(this, k).toString(),
+        hostName: e.workerThreadWorkerOptions.hostName ? e.workerThreadWorkerOptions.hostName : "host",
+        agentName: `${e.workerThreadWorkerOptions.agentId}-${e.workerThreadWorkerOptions.userAgent}`,
+        threadId: `worker${e.id}`,
+        asyncRunnerId: n(this, k)
+      }, o = {
+        id: n(this, k),
+        publishInstrumentController: n(this, R).AddPublishInstrumentController(r),
+        asyncRunnerContext: r,
+        state: C.created,
+        options: t,
+        instrumentData: {
+          count: 0,
+          velocity: 0,
+          message: []
+        },
+        Stop: async () => n(this, $).call(this, e, o)
+      };
+      return o;
+    });
+    // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+    l(this, W, (e, t, r, o) => {
+      o ? (console.log("#PostMessageToWorker with transfer object"), e.worker.postMessage({ command: t, payload: r }, [o]), console.log("#PostMessageToWorker with transfer object - done...")) : (console.log("#PostMessageToWorker"), e.worker.postMessage({ command: t, payload: r }));
+    });
+    l(this, L, (e) => {
+      if (e.worker) {
+        const t = re();
+        e.worker.terminate(), console.log(`Terminated worker: [${e.id}]`), t.RemoveWorker(e), delete n(this, O)[e.id];
+      }
+    });
+    l(this, $, async (e, t = null) => {
+      if (t === null) {
+        const r = Object.keys(e.runnersEx);
+        if (r.length > 0) {
+          const o = r[0];
+          t = e.runnersEx[o];
+        }
+      }
+      if (t !== null) {
+        n(this, W).call(this, e, h.Stop, {
+          runner: ee(this, N, ce).call(this, t)
+        }), t.publishInstrumentController.LogEx(`Terminating runner: [${t.id}]`);
+        const r = [];
+        r.push((async () => (await ke(100), t.publishInstrumentController.InstrumentTerminate()))()), re().RemoveRunner(e, t), delete e.runnersEx[t.id];
+        const i = await Promise.all(r);
+        console.log(`Removed instrument workers: [${i}]`);
+      }
+      return !0;
+    });
+    l(this, F, async (e) => {
+      try {
+        if (e.state !== q.stopped) {
+          n(this, W).call(this, e, h.Stop, null), console.log(`Terminating worker: [${e.id}]`);
+          const t = [];
+          Object.keys(e.runnersEx).forEach((o) => {
+            const i = e.runnersEx[o];
+            t.push(n(this, $).call(this, e, i));
+          }), await Promise.all(t), n(this, L).call(this, e);
+        }
+        return !0;
+      } catch (t) {
+        return console.log(`Error in STSTestWorker:StopWorker: [${t}]`), !1;
+      }
+    });
+    c(this, "GetNextAvailableWorker", () => {
+      let e = null;
+      for (const [, t] of Object.entries(this.WorkersEx))
+        e ? Object.keys(t.runnersEx).length < Object.keys(e.runnersEx).length && (e = t) : e = t;
+      return e;
+    });
+    c(this, "GetBusyWorker", () => {
+      let e = null;
+      for (const [, t] of Object.entries(this.WorkersEx))
+        e ? Object.keys(t.runnersEx).length > Object.keys(e.runnersEx).length && (e = t) : e = t;
+      return e;
+    });
+    /*
+    StopRunner = async () => {
+        // Calculate the worker with the most runners
+        let largestRunnerWorker: IWorkerEx | null = null;
+        for (const [, stsWorker] of Object.entries(this.WorkersEx)) {
+            if (largestRunnerWorker) {
+                if (Object.keys(stsWorker.runnersEx).length > Object.keys(largestRunnerWorker.runnersEx).length) {
+                    largestRunnerWorker = stsWorker;
+                }
+            } else {
+                largestRunnerWorker = stsWorker;
+            }
+        }
+        if (largestRunnerWorker) largestRunnerWorker.StopRunner();
+    }
+    */
+    /*
+    StopWorker = async () => {
+        // Calculate the worker with the least runners
+        let largestRunnerWorker: IWorkerEx | null = null;
+        for (const [, stsWorker] of Object.entries(this.WorkersEx)) {
+            if (largestRunnerWorker) {
+                if (Object.keys(stsWorker.runnersEx).length < Object.keys(largestRunnerWorker.runnersEx).length) {
+                    largestRunnerWorker = stsWorker;
+                }
+            } else {
+                largestRunnerWorker = stsWorker;
+            }
+        }
+        if (largestRunnerWorker) largestRunnerWorker.Stop();
+    }
+    */
+    c(this, "StopAllWorkers", async () => {
+      const e = [];
+      for (const [, t] of Object.entries(this.WorkersEx))
+        e.push(t.Stop());
+      await Promise.all(e);
+    });
+    g(this, D, e), t ? g(this, T, t) : g(this, T, {}), P(`CompareSTSInstrumentControllerPluginKeyWMEx(): [${we()}]`), P(`Attempting to get STSInstrumentControllerPlugin using symbol: [${String(A)}]`), g(this, R, fe(e)), P(n(this, R)), P("keys within app.config.globalProperties.$sts");
+    for (const [r, o] of Object.entries(e.config.globalProperties.$sts))
+      P(`${r}`);
+    n(this, R) || P(`Failed to get STSInstrumentControllerPlugin using symbol: [${String(A)}]`);
+  }
+  get WorkersEx() {
+    return n(this, O);
+  }
+  get Options() {
+    return n(this, T);
+  }
+  set Options(e) {
+    g(this, T, e);
+  }
+}
+O = new WeakMap(), k = new WeakMap(), j = new WeakMap(), T = new WeakMap(), R = new WeakMap(), D = new WeakMap(), N = new WeakSet(), ce = function(e) {
+  return {
+    id: e.id,
+    asyncRunnerContext: { ...e.asyncRunnerContext },
+    options: { ...e.options },
+    state: e.state,
+    instrumentData: { ...e.instrumentData }
+  };
+}, E = new WeakMap(), J = new WeakMap(), H = new WeakMap(), W = new WeakMap(), L = new WeakMap(), $ = new WeakMap(), F = new WeakMap();
+const Ke = () => A, Be = (s) => s === A, we = () => A === Se(), ze = () => ue(ie), Ve = {
+  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+  install: (s, e) => {
+    const t = new be(s, e);
+    s.config.globalProperties.$sts || (s.config.globalProperties.$sts = {}), s.config.globalProperties.$sts[ie] = t, s.provide(ie, t);
+  }
+}, w = Y(`proc:${process.pid}`);
+var d, G, I, K;
+class Ce {
+  constructor(e) {
+    l(this, d, {});
+    l(this, G, 1e4);
+    //@@ config
+    l(this, I, void 0);
+    c(this, "PostMessage", (e) => new Promise((t, r) => {
+      const { messageId: o } = e.payload;
+      if (o)
+        n(this, d)[o] ? r(`RequestResponseHelper: Message with id: [${o}] already exists within the Request/Response record structure`) : (n(this, d)[o] = {
+          publishMessagePayload: { ...e },
+          cb: () => {
+            const i = n(this, d)[o].publishMessagePayloadResponse;
+            if (clearTimeout(n(this, d)[o].timeout), setTimeout(() => {
+              delete n(this, d)[o];
+            }, 0), i)
+              w(`RequestResponseHelper: Resolving response message with id: [${o}] from target worker port. Details: [${JSON.stringify(i)}]`), t(i);
+            else {
+              const a = "Could not get detail from this.#requestResponseMessages[messageId].publishMessagePayloadResponse";
+              w(a), r(a);
+            }
+          },
+          timeout: setTimeout(() => {
+            setTimeout(() => {
+              delete n(this, d)[o];
+            }, 0), w(`RequestResponseHelper: Timeout has occurred after: [${n(this, G)}]ms with message id: [${o}]. Details: [${JSON.stringify(n(this, d)[o].publishMessagePayload)}]`), r("RequestResponseHelper: Did not receive response form parent process.");
+          }, n(this, G))
+          // max message timeout allowed
+        }, w(`RequestResponseHelper: Sending message with id: [${o}] to target worker port. Details: [${JSON.stringify(n(this, d)[o].publishMessagePayload)}]`), n(this, I).postMessage(e));
+      else {
+        const i = "RequestResponseHelper: Response did not include a message id";
+        w(i), r(i);
+      }
+    }));
+    l(this, K, () => {
+      n(this, I).onmessage = async (e) => {
+        const t = e.data;
+        if (t.payload.messageId) {
+          const r = t.payload.messageId;
+          if (r && r !== "")
+            if (n(this, d)[r]) {
+              const o = n(this, d)[r];
+              o.publishMessagePayloadResponse = { ...t }, o.cb();
+            } else
+              throw new Error(`RequestResponseHelper: Could not find Request/Response message with id: [${r}]`);
+        }
+      };
+    });
+    g(this, I, e), n(this, K).call(this);
+  }
+}
+d = new WeakMap(), G = new WeakMap(), I = new WeakMap(), K = new WeakMap();
+const f = Y(`proc:${process.pid}:workerInstance`);
+var S, U, M, b, B, z, V;
+class Ye {
+  constructor() {
+    l(this, S, null);
+    l(this, U, null);
+    l(this, M, {});
+    l(this, b, null);
+    c(this, "GetRandomInt", (e) => (f("WorkerInstance::GetRandomInt"), Math.floor(Math.random() * Math.floor(e))));
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    c(this, "StartWork", async (e) => {
+      f("WorkerInstance::StartWork");
+    });
+    c(this, "PostTelemetry", (e) => {
+      if (n(this, S)) {
+        const t = {
+          command: h.InstrumentTelemetry,
+          payload: {
+            runner: e
+          }
+        };
+        n(this, S).postMessage(t);
+      }
+    });
+    l(this, B, (e) => {
+      f("WorkerInstance::SetMessagePort"), g(this, S, e.port), n(this, S).onmessage = function(r) {
+        console.log(`collectorCollectorPort onmessage: ${r.data}`);
+      }, g(this, U, new Ce(n(this, S)));
+      const t = {
+        command: h.MessagePortResponse,
+        payload: {}
+      };
+      n(this, S).postMessage(t);
+    });
+    c(this, "StartRunner", async (e) => {
+      f("WorkerInstance::StartRunner"), console.log(`StartTests: [${JSON.stringify(e)}]`), e.state = C.running, this.StartWork(e);
+    });
+    l(this, z, (e) => {
+      f("WorkerInstance::AddAsyncRunner");
+      const { runner: t } = e;
+      n(this, M)[t.id] = t, this.StartRunner(t);
+    });
+    l(this, V, (e) => {
+      if (f("WorkerInstance::StopRunners"), e === null)
+        for (const [, t] of Object.entries(n(this, M)))
+          t.state = C.stopped;
+      else {
+        const t = n(this, M)[e.runner.id];
+        t && (t.state = C.stopped);
+      }
+    });
+    c(this, "ProcessMessage", async (e) => {
+      f("WorkerInstance::ProcessMessage");
+      try {
+        const t = e.data;
+        switch (t.command) {
+          case h.MessagePort:
+            n(this, B).call(this, t.payload), g(this, b, t.payload.options), f(`WorkerInstance::ProcessMessage::#options: [${JSON.stringify(n(this, b))}]`);
+            break;
+          case h.Add:
+            n(this, z).call(this, t.payload);
+            break;
+          case h.Stop:
+            n(this, V).call(this, t.payload);
+            break;
+          default:
+            f(`Invalid payloadMessage.command: [${t.command}] - Ignoring`);
+        }
+      } catch (t) {
+        console.log(t);
+      }
+    });
+    f("WorkerInstance::constructor");
+  }
+  get RequestResponseHelper() {
+    return n(this, U);
+  }
+  get CollectorCollectorPort() {
+    return n(this, S);
+  }
+  get Options() {
+    return n(this, b);
+  }
+}
+S = new WeakMap(), U = new WeakMap(), M = new WeakMap(), b = new WeakMap(), B = new WeakMap(), z = new WeakMap(), V = new WeakMap();
+export {
+  Me as ClientStorageFactory,
+  Pe as ClientStorageType,
+  Be as CompareSTSInstrumentControllerPluginKeyWM,
+  we as CompareSTSInstrumentControllerPluginKeyWMEx,
+  Ke as GetSTSInstrumentControllerPluginKeyWM,
+  C as IRunnerState,
+  q as IWorkerState,
+  Ce as RequestResponseHelper,
+  He as STSEmitterPlugin,
+  ne as STSEmitterPluginKey,
+  Fe as STSStoragePlugin,
+  oe as STSStoragePluginKey,
+  be as STSWorkerManager,
+  Ve as STSWorkerManagerPlugin,
+  ie as STSWorkerManagerPluginKey,
+  re as TelemetryStore,
+  Ye as WorkerInstance,
+  Je as useSTSEmitterPlugin,
+  Le as useSTSStoragePlugin,
+  ze as useSTSWorkerManager
+};
+//# sourceMappingURL=stsvueutils.mjs.map