@nsshunt/ststestrunner 1.0.34 → 1.0.36

package/dist/ststestrunner.mjs

@@ -20095,8 +20095,63 @@ function strToU8(str, latin1) {
   }
   return slc(ar2, 0, ai);
 }
-class ServiceInstance {
+var tinyEmitter = { exports: {} };
+var hasRequiredTinyEmitter;
+function requireTinyEmitter() {
+  if (hasRequiredTinyEmitter) return tinyEmitter.exports;
+  hasRequiredTinyEmitter = 1;
+  function E2() {
+  }
+  E2.prototype = {
+    on: function(name, callback, ctx) {
+      var e2 = this.e || (this.e = {});
+      (e2[name] || (e2[name] = [])).push({
+        fn: callback,
+        ctx
+      });
+      return this;
+    },
+    once: function(name, callback, ctx) {
+      var self2 = this;
+      function listener() {
+        self2.off(name, listener);
+        callback.apply(ctx, arguments);
+      }
+      listener._ = callback;
+      return this.on(name, listener, ctx);
+    },
+    emit: function(name) {
+      var data = [].slice.call(arguments, 1);
+      var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
+      var i = 0;
+      var len = evtArr.length;
+      for (i; i < len; i++) {
+        evtArr[i].fn.apply(evtArr[i].ctx, data);
+      }
+      return this;
+    },
+    off: function(name, callback) {
+      var e2 = this.e || (this.e = {});
+      var evts = e2[name];
+      var liveEvents = [];
+      if (evts && callback) {
+        for (var i = 0, len = evts.length; i < len; i++) {
+          if (evts[i].fn !== callback && evts[i].fn._ !== callback)
+            liveEvents.push(evts[i]);
+        }
+      }
+      liveEvents.length ? e2[name] = liveEvents : delete e2[name];
+      return this;
+    }
+  };
+  tinyEmitter.exports = E2;
+  tinyEmitter.exports.TinyEmitter = E2;
+  return tinyEmitter.exports;
+}
+var tinyEmitterExports = requireTinyEmitter();
+class ServiceInstance extends tinyEmitterExports.TinyEmitter {
   constructor(options) {
+    super();
     __privateAdd(this, _options5);
     __privateAdd(this, _id2, v4());
     __privateAdd(this, _clientName, "");
@@ -20115,6 +20170,7 @@ class ServiceInstance {
       };
     });
     __privateAdd(this, _LogPayloadEventRetVal, (retVal) => {
+      __privateGet(this, _EmitEvent).call(this, `IEventReturnValueBase`, retVal);
       return retVal;
     });
     __publicField(this, "Stop", async () => {
@@ -20167,12 +20223,18 @@ class ServiceInstance {
         var _a2;
         __privateGet(this, _debug5).call(this, chalk$1.yellow(`${__privateGet(this, _id2)} ${__privateGet(this, _clientName)}:  --> AddRunner: [${JSON.stringify(options)}]`));
         const runnerEx = await ((_a2 = __privateGet(this, _wm).GetNextAvailableWorker()) == null ? void 0 : _a2.AddRunner(options));
+        if (runnerEx) {
+          __privateGet(this, _EmitEvent).call(this, "AddRunner", __privateGet(this, _wm).CreateRunnerCopy(runnerEx));
+        } else {
+          __privateGet(this, _EmitEvent).call(this, "AddRunner", {});
+        }
         StartRunnerAndRespond(IEventRequestCommand.AddRunner, runnerEx, cb);
       });
       socket.on("AddRunnerToWorker", async (workerId, options, cb) => {
         __privateGet(this, _debug5).call(this, chalk$1.yellow(`${__privateGet(this, _id2)} ${__privateGet(this, _clientName)}:  --> AddRunnerToWorker: workerId: [${workerId}] options: [${JSON.stringify(options)}]`));
         const workerEx = __privateGet(this, _wm).WorkersEx[workerId];
         const runnerEx = await (workerEx == null ? void 0 : workerEx.AddRunner(options));
+        __privateGet(this, _EmitEvent).call(this, "AddRunnerToWorker", __privateGet(this, _wm).CreateRunnerCopy(runnerEx));
         StartRunnerAndRespond(IEventRequestCommand.AddRunnerToWorker, runnerEx, cb);
       });
     });
@@ -20350,82 +20412,67 @@ class ServiceInstance {
     });
     // Loop through and attach handlers automatically
     __privateAdd(this, _RegisterSocketEvents, (socket, clientName) => {
-      const logPrefix = `${__privateGet(this, _id2)} ${clientName}:`;
+      `${__privateGet(this, _id2)} ${clientName}:`;
       const handlers = __privateGet(this, _GetSocketEventHandlers).call(this, socket, clientName);
       for (const [event, handler] of Object.entries(handlers)) {
         const wrappedHandler = async (...args) => {
-          if (typeof args.at(-1) === "function") {
-            __privateGet(this, _debug5).call(this, chalk$1.yellow(`${logPrefix} --> ${event} (with callback): ${JSON.stringify(args, null, 2)}`));
-            console.log(args);
-            const cb = args.at(-1);
-            const inputArgs = args.slice(0, -1);
-            try {
-              console.log(`Before result call...`);
-              const result = await handler(...inputArgs);
-              console.log(`After result call...`);
-              console.log(result);
-              __privateGet(this, _debug5).call(this, chalk$1.yellow(`${logPrefix} --> ${event}: ${JSON.stringify(args, null, 2)} = [${JSON.stringify(result, null, 2)}]`));
-              const res = __privateGet(this, _EmitEvent).call(this, event, result);
-              console.log(`res...`);
-              console.log(res);
-              cb(res);
-            } catch (err) {
-              __privateGet(this, _error2).call(this, `${logPrefix} error in ${event}: ${err}`);
-              __privateGet(this, _error2).call(this, chalk$1.red(`${logPrefix} --> ${event}: ${JSON.stringify(args, null, 2)} = Error: [${err}]`));
-              cb({ error: err instanceof Error ? err.message : String(err) });
-            }
-          } else {
-            __privateGet(this, _debug5).call(this, chalk$1.yellow(`${logPrefix} --> ${event}: ${JSON.stringify(args, null, 2)}`));
-            return handler(...args);
-          }
+          return handler(...args);
         };
         socket.on(event, wrappedHandler);
       }
       __privateGet(this, _HandleAddRunner).call(this, socket);
     });
     __privateAdd(this, _EmitEvent, (eventName, data) => {
-      console.log(chalk$1.rgb(60, 20, 200)`Going to emit event: [${eventName}] with data: [${JSON.stringify(data, null, 2)}]`);
+      this.emit(eventName, data);
       return data;
     });
     __privateAdd(this, _GetSocketEventHandlers, (socket, clientName) => {
       const logPrefix = `${__privateGet(this, _id2)} ${clientName}:`;
       return {
         // socketio and standard events
-        "disconnect": (reason) => __privateGet(this, _error2).call(this, `#disconnect(): [${reason}]`),
+        "disconnect": (reason) => {
+          __privateGet(this, _EmitEvent).call(this, "connect_error", reason);
+          __privateGet(this, _error2).call(this, `#disconnect(): [${reason}]`);
+        },
         "connect_error": (error) => {
+          __privateGet(this, _EmitEvent).call(this, "connect_error", error);
           if (!socket.active) {
             __privateGet(this, _error2).call(this, error.message);
           }
         },
         "__STSdisconnect": (reason) => {
+          __privateGet(this, _EmitEvent).call(this, "__STSdisconnect", reason);
           __privateGet(this, _debug5).call(this, chalk$1.magenta(`${logPrefix}: [${socket.id}] [${reason}]`));
           this.Stop();
         },
-        "error": (error) => __privateGet(this, _error2).call(this, `#GetSocketEventHandlers(): [${error}]`),
+        "error": (error) => {
+          __privateGet(this, _EmitEvent).call(this, "error", error);
+          __privateGet(this, _error2).call(this, `#GetSocketEventHandlers(): [${error}]`);
+        },
         // utility commands
-        "GetService": async (cb) => cb(await this.GetService()),
-        "GetArchiveList": async (runnerSearchFilters, cb) => cb(await this.GetArchiveList(runnerSearchFilters)),
+        "GetService": async (cb) => cb(__privateGet(this, _EmitEvent).call(this, "GetService", await this.GetService())),
+        "GetArchiveList": async (runnerSearchFilters, cb) => cb(__privateGet(this, _EmitEvent).call(this, "GetArchiveList", await this.GetArchiveList(runnerSearchFilters))),
         // Workers commands
-        "AddWorker": async (options, cb) => cb(await this.AddWorker(options)),
-        "GetWorkers": async (cb) => cb(await this.GetWorkers()),
-        "GetWorkersSmall": async (states, cb) => cb(await this.GetWorkersSmall(states)),
-        "StartWorkers": async (workerIds, cb) => cb(await this.StartWorkers(workerIds)),
-        "StopWorkers": async (workerIds, cb) => cb(await this.StopWorkers(workerIds)),
-        "PauseWorkers": async (workerIds, cb) => cb(await this.PauseWorkers(workerIds)),
-        "ResumeWorkers": async (workerIds, cb) => cb(await this.ResumeWorkers(workerIds)),
-        "ExecuteWorkers": async (workerIds, cb) => cb(await this.ExecuteWorkers(workerIds)),
-        "ResetWorkers": async (workerIds, cb) => cb(await this.ResetWorkers(workerIds)),
-        "TerminateWorkers": async (workerIds, cb) => cb(await this.TerminateWorkers(workerIds)),
-        "UpdateWorkers": async (workerIds, options, cb) => cb(await this.UpdateWorkers(workerIds, options)),
+        "AddWorker": async (options, cb) => cb(__privateGet(this, _EmitEvent).call(this, "AddWorker", await this.AddWorker(options))),
+        "GetWorkers": async (cb) => cb(__privateGet(this, _EmitEvent).call(this, "GetWorkers", await this.GetWorkers())),
+        "GetWorkersSmall": async (states, cb) => cb(__privateGet(this, _EmitEvent).call(this, "GetWorkersSmall", await this.GetWorkersSmall(states))),
+        "StartWorkers": async (workerIds, cb) => cb(__privateGet(this, _EmitEvent).call(this, "StartWorkers", await this.StartWorkers(workerIds))),
+        "StopWorkers": async (workerIds, cb) => cb(__privateGet(this, _EmitEvent).call(this, "StopWorkers", await this.StopWorkers(workerIds))),
+        "PauseWorkers": async (workerIds, cb) => cb(__privateGet(this, _EmitEvent).call(this, "PauseWorkers", await this.PauseWorkers(workerIds))),
+        "ResumeWorkers": async (workerIds, cb) => cb(__privateGet(this, _EmitEvent).call(this, "ResumeWorkers", await this.ResumeWorkers(workerIds))),
+        "ExecuteWorkers": async (workerIds, cb) => cb(__privateGet(this, _EmitEvent).call(this, "ExecuteWorkers", await this.ExecuteWorkers(workerIds))),
+        "ResetWorkers": async (workerIds, cb) => cb(__privateGet(this, _EmitEvent).call(this, "ResetWorkers", await this.ResetWorkers(workerIds))),
+        "TerminateWorkers": async (workerIds, cb) => cb(__privateGet(this, _EmitEvent).call(this, "TerminateWorkers", await this.TerminateWorkers(workerIds))),
+        "UpdateWorkers": async (workerIds, options, cb) => cb(__privateGet(this, _EmitEvent).call(this, "UpdateWorkers", await this.UpdateWorkers(workerIds, options))),
         // Runner Commands (All)
-        "StartRunners": async (workerId, runnerIds, cb) => cb(await this.StartRunners(workerId, runnerIds)),
-        "StopRunners": async (workerId, runnerIds, cb) => cb(await this.StopRunners(workerId, runnerIds)),
-        "PauseRunners": async (workerId, runnerIds, cb) => cb(await this.PauseRunners(workerId, runnerIds)),
-        "ResumeRunners": async (workerId, runnerIds, cb) => cb(await this.ResumeRunners(workerId, runnerIds)),
-        "ExecuteRunners": async (workerId, runnerIds, cb) => cb(await this.ExecuteRunners(workerId, runnerIds)),
-        "ResetRunners": async (workerId, runnerIds, cb) => cb(await this.ResetRunners(workerId, runnerIds)),
-        "TerminateRunners": async (workerId, runnerIds, cb) => cb(await this.TerminateRunners(workerId, runnerIds)),
-        "UpdateRunners": async (workerId, runnerIds, options, cb) => cb(await this.UpdateRunners(workerId, runnerIds, options))
+        "StartRunners": async (workerId, runnerIds, cb) => cb(__privateGet(this, _EmitEvent).call(this, "StartRunners", await this.StartRunners(workerId, runnerIds))),
+        "StopRunners": async (workerId, runnerIds, cb) => cb(__privateGet(this, _EmitEvent).call(this, "StopRunners", await this.StopRunners(workerId, runnerIds))),
+        "PauseRunners": async (workerId, runnerIds, cb) => cb(__privateGet(this, _EmitEvent).call(this, "PauseRunners", await this.PauseRunners(workerId, runnerIds))),
+        "ResumeRunners": async (workerId, runnerIds, cb) => cb(__privateGet(this, _EmitEvent).call(this, "ResumeRunners", await this.ResumeRunners(workerId, runnerIds))),
+        "ExecuteRunners": async (workerId, runnerIds, cb) => cb(__privateGet(this, _EmitEvent).call(this, "ExecuteRunners", await this.ExecuteRunners(workerId, runnerIds))),
+        "ResetRunners": async (workerId, runnerIds, cb) => cb(__privateGet(this, _EmitEvent).call(this, "ResetRunners", await this.ResetRunners(workerId, runnerIds))),
+        "TerminateRunners": async (workerId, runnerIds, cb) => cb(__privateGet(this, _EmitEvent).call(this, "TerminateRunners", await this.TerminateRunners(workerId, runnerIds))),
+        "UpdateRunners": async (workerId, runnerIds, options, cb) => cb(__privateGet(this, _EmitEvent).call(this, "UpdateRunners", await this.UpdateRunners(workerId, runnerIds, options)))
       };
     });
     __privateSet(this, _options5, options);