@nsshunt/stssocketioutils 1.1.39 → 2.0.0

package/dist/stssocketioutils.mjs

@@ -1,4 +1,10 @@
 import { io } from "socket.io-client";
+import { Sleep } from "@nsshunt/stsutils";
+import { Server } from "socket.io";
+import { Redis } from "ioredis";
+import require$$0 from "node:cluster";
+import require$$1 from "socket.io-adapter";
+import { createAdapter } from "@socket.io/redis-streams-adapter";
 var STSNamespace = /* @__PURE__ */ ((STSNamespace2) => {
   STSNamespace2["STSMonitor"] = "stsinstrumentmanager/stsmonitor";
   STSNamespace2["STSControl"] = "stsinstrumentmanager/stscontrol";
@@ -113,15 +119,6 @@ class SocketIoClient {
       throw new Error("SocketIoClient:emit(): Error: [socket instance not defined.]");
     }
   }
-  /*
-  SetupClientSideSocket(name: string, address: string, socketIoCustomPath: string): SocketIoClient<ServerToClientEvents, ClientToServerEvents> {
-      this.#name = name;
-      this.#address = address;
-      this.#socketIoCustomPath = socketIoCustomPath;
-      this.#EstablishSocketConnect(name, socketIoCustomPath);
-      return this;
-  }
-  */
   #EstablishSocketConnect() {
     if (this.#socket !== void 0) {
       if (this.#socket.connected === true) {
@@ -233,132 +230,823 @@ class SocketIoClient {
     });
   }
 }
-class SocketIoServerHelper {
-  #socketIoServerHelperOptions;
-  #namespace = {};
-  constructor(options) {
-    this.#socketIoServerHelperOptions = options;
-  }
-  LogMessage(namespace, message) {
-    if (namespace) {
-      this.#socketIoServerHelperOptions.logger.debug(`${namespace.namespace}: ${message}`);
-    } else {
-      this.#socketIoServerHelperOptions.logger.debug(`${message}`);
+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);
+  const socket_io_adapter_1 = require$$1;
+  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() {
   }
-  LeaveRoom = (namespace, socket, room) => {
-    this.LogMessage(namespace, `${namespace.socketionamespace.name}: Leaving room [${room}]`);
+  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;
+}
+var distExports = requireDist();
+class SocketIoServer {
+  namespace;
+  socketionamespace;
+  //protected socketionamespace?: Namespace<ClientToServerEvents, ServerToClientEvents, InterServerEvents>
+  logger;
+  io;
+  //#redisClient: RedisClientType | Redis | null = null;
+  redisClient;
+  constructor(namespace, logger) {
+    this.namespace = namespace;
+    this.logger = logger;
+  }
+  LogErrorMessage(message) {
+    if (this.logger) {
+      this.logger.error(`${this.namespace}: ${message}`);
+    }
+  }
+  LogDebugMessage(message) {
+    if (this.logger) {
+      this.logger.debug(`${this.namespace}: ${message}`);
+    }
+  }
+  LogInfoMessage(message) {
+    if (this.logger) {
+      this.logger.info(`${this.namespace}: ${message}`);
+    }
+  }
+  LogWarnMessage(message) {
+    if (this.logger) {
+      this.logger.warn(`${this.namespace}: ${message}`);
+    }
+  }
+  // https://socket.io/docs/v4/middlewares/
+  // https://socket.io/docs/v4/server-socket-instance/#sockethandshake
+  // https://socket.io/docs/v4/server-socket-instance/#socket-middlewares
+  // Use this middleward to check every incomming connection
+  SetupConnectionMiddleware = () => {
+  };
+  // Use this middleware to check every packet being received
+  SetupMessageMiddleware = (socket) => {
+  };
+  SocketConnectCallBack = (socket) => {
+  };
+  SocketEventsCallBack = (socket) => {
+  };
+  GetConfig = (socketIoServeroptions) => {
+    const options = {
+      transports: ["websocket"]
+      // or [ "websocket", "polling" ] (to use long-poolling. Note that the order matters)
+    };
+    if (socketIoServeroptions.ioRedisMessageProcessorUrl && socketIoServeroptions.ioRedisMessageProcessorUrl !== "") {
+      this.redisClient = new Redis(socketIoServeroptions.ioRedisMessageProcessorUrl);
+      options.adapter = createAdapter(this.redisClient);
+    } else if (socketIoServeroptions.serverClusterMode && socketIoServeroptions.serverClusterMode === true) {
+      options.adapter = distExports.createAdapter();
+    }
+    if (socketIoServeroptions.wssCustomPath && socketIoServeroptions.wssCustomPath.localeCompare("") !== 0) {
+      options.path = socketIoServeroptions.wssCustomPath;
+    }
+    return options;
+  };
+  SetEngineEvents = () => {
+    if (this.io) {
+      this.io.engine.on("connection_error", (err) => {
+        this.LogInfoMessage(err.req);
+        this.LogInfoMessage(err.code);
+        this.LogInfoMessage(err.message);
+        this.LogInfoMessage(err.context);
+      });
+    }
+  };
+  StartServer = async (socketIoServeroptions) => {
+    if (this.io) {
+      throw new Error(`SocketIoServer:StartServer(): Error: [Server already exists]`);
+    }
+    if (!socketIoServeroptions.listenPort) {
+      throw new Error(`SocketIoServer:StartServer(): Error: [listenPort not specified]`);
+    }
+    this.io = new Server(socketIoServeroptions.listenPort, this.GetConfig(socketIoServeroptions));
+    this.SetEngineEvents();
+    await Sleep(500);
+  };
+  AttachServer = async (server, socketIoServeroptions) => {
+    if (this.io) {
+      throw new Error(`SocketIoServer:AttachServer(): Error: [Server already attached]`);
+    }
+    if (socketIoServeroptions.listenPort) {
+      this.LogWarnMessage(`SocketIoServer:AttachServer(): Warning: [listenPort: [${socketIoServeroptions.listenPort}] has been specified, but ignored as attaching to existing server]`);
+    }
+    this.io = new Server(server, this.GetConfig(socketIoServeroptions));
+    this.SetEngineEvents();
+    await Sleep(500);
+  };
+  StopServer = async () => {
+    if (this.io) {
+      await this.CloseNamespaceAdaptors();
+      this.DisconnectNamespaceSockets();
+      await this.io.of("/").adapter.close();
+      if (this.redisClient) {
+        await this.redisClient.disconnect();
+        await Sleep(50);
+      }
+      this.io.disconnectSockets();
+      this.io = void 0;
+    }
+  };
+  LeaveRoom = (socket, room) => {
+    this.LogDebugMessage(`Leaving room [${room}]`);
     socket.leave(room);
   };
-  JoinRoom = (namespace, socket, room) => {
-    this.LogMessage(namespace, `${namespace.socketionamespace.name}: Socket joining room [${room}], ID: [${socket.id}]`);
+  JoinRoom = (socket, room) => {
+    this.LogDebugMessage(`Socket joining room [${room}], ID: [${socket.id}]`);
     socket.join(room);
   };
-  #SetupStandardEvents = (namespace, socket) => {
+  SetupStandardEvents = (socket) => {
     socket.on("disconnect", (reason) => {
-      this.LogMessage(namespace, `${namespace.socketionamespace.name}: socket disconnect, ID: [${socket.id}] [${reason}]`);
+      this.LogDebugMessage(`socket disconnect, ID: [${socket.id}] [${reason}]`);
     });
     socket.on("disconnecting", (reason) => {
-      this.LogMessage(namespace, `${namespace.socketionamespace.name}: socket disconnecting, ID: [${socket.id}] [${reason}]`);
+      this.LogDebugMessage(`socket disconnecting, ID: [${socket.id}] [${reason}]`);
     });
     socket.on("error", (error) => {
-      this.LogMessage(namespace, `${namespace.socketionamespace.name}: socket error, ID: [${socket.id}] [${error}]`);
+      this.LogDebugMessage(`socket error, ID: [${socket.id}] [${error}]`);
     });
     socket.on("__STSdisconnect", (reason) => {
-      this.LogMessage(namespace, `${namespace.socketionamespace.name}: __STSdisconnect: socket disconnect, ID: [${socket.id}] [${reason}]`);
+      this.LogDebugMessage(`__STSdisconnect: socket disconnect, ID: [${socket.id}] [${reason}]`);
     });
     socket.on("__STSdisconnecting", (reason, callBackResult) => {
-      this.LogMessage(namespace, `${namespace.socketionamespace.name}: __STSdisconnecting: socket disconnecting, ID: [${socket.id}] [${reason}]`);
+      this.LogDebugMessage(`__STSdisconnecting: socket disconnecting, ID: [${socket.id}] [${reason}]`);
       callBackResult("__STSdisconnecting accepted by server.");
     });
     socket.on("__STSjoinRoom", (rooms) => {
       rooms.forEach((room) => {
-        this.JoinRoom(namespace, socket, room);
+        this.JoinRoom(socket, room);
       });
     });
     socket.on("__STSleaveRoom", (rooms) => {
       rooms.forEach((room) => {
-        this.LeaveRoom(namespace, socket, room);
+        this.LeaveRoom(socket, room);
       });
     });
     socket.on("__STSsendToRoom", (rooms, payload) => {
       rooms.forEach((room) => {
-        this.LogMessage(namespace, `${namespace.socketionamespace.name}:socket.on:sendToRoom: __STSsendToRoom: Sending to room [${room}], ID: [${socket.id}]`);
-        namespace.socketionamespace.to(room).emit(payload.command, payload);
+        if (this.socketionamespace) {
+          this.LogDebugMessage(`socket.on: __STSsendToRoom: Sending to room [${room}], ID: [${socket.id}]`);
+          this.socketionamespace.to(room).emit(payload.command, payload);
+        }
       });
     });
-  };
-  // https://socket.io/docs/v4/middlewares/
-  // https://socket.io/docs/v4/server-socket-instance/#sockethandshake
-  // https://socket.io/docs/v4/server-socket-instance/#socket-middlewares
-  // Use this middleward to check every incomming connection
-  #SetupConnectionMiddleware = (nameSpace) => {
-    nameSpace.socketionamespace.use((socket, next) => {
-      {
-        next();
+    socket.on("__STSsendToRoomWithCallback", (room, timeout, payload, cb) => {
+      if (this.socketionamespace) {
+        this.socketionamespace.to(room).timeout(timeout).emit(payload.command, payload, (err, dataResponse) => {
+          if (err) {
+            console.error(err);
+            const errorResponse = {
+              error: true,
+              errorName: err.name,
+              errorMessage: err.message
+              //errorCause: err.cause,
+              //errorStack: err.stack
+            };
+            this.LogErrorMessage(`__STSsendToRoomWithCallback broadcast (error): [${JSON.stringify(errorResponse)}]`);
+            cb(errorResponse);
+          } else {
+            this.LogDebugMessage(`__STSsendToRoomWithCallback broadcast: [${JSON.stringify(dataResponse)}]`);
+            cb(dataResponse);
+          }
+        });
       }
     });
-  };
-  // Use this middleware to check every packet being received
-  #SetupMessageMiddleware = (socket) => {
-    socket.use(([event, ...args], next) => {
-      next();
+    socket.on("__STSsendToRoomsWithCallback", (rooms, timeout, payload, cb) => {
+      const responses = [];
+      const timeoutForComplete = setTimeout(() => {
+        responses.push({
+          room: "",
+          responses: {
+            error: true,
+            errorName: "timeout",
+            errorMessage: `__STSsendToRoomsWithCallback timeout: [${timeout}] before all responses received`
+          }
+        });
+        cb(responses);
+      }, timeout).unref();
+      rooms.forEach((room) => {
+        if (this.socketionamespace) {
+          this.socketionamespace.to(room).timeout(timeout).emit(payload.command, payload, (err, dataResponse) => {
+            if (err) {
+              console.error(err);
+              const errorResponse = {
+                error: true,
+                errorName: err.name,
+                errorMessage: err.message
+                //errorCause: err.cause,
+                //errorStack: err.stack
+              };
+              this.LogErrorMessage(`__STSsendToRoomWithCallback broadcast (error): [${JSON.stringify(errorResponse)}]`);
+              responses.push({
+                room,
+                responses: errorResponse
+              });
+            } else {
+              this.LogDebugMessage(`__STSsendToRoomWithCallback broadcast: [${JSON.stringify(dataResponse)}]`);
+              responses.push({
+                room,
+                responses: dataResponse
+              });
+            }
+            if (responses.length === rooms.length) {
+              clearTimeout(timeoutForComplete);
+              cb(responses);
+            }
+          });
+        }
+      });
     });
   };
-  SetupNamespace = (io2, namespace, rooms, autoJoinRooms, socketConnectCallBack, socketEventsCallBack) => {
-    this.#namespace[namespace] = {
-      namespace,
-      pid: process.pid,
-      socketionamespace: io2.of(`/${namespace}/`)
-    };
-    this.#SetupConnectionMiddleware(this.#namespace[namespace]);
-    this.#namespace[namespace].socketionamespace.on("connection", (socket) => {
-      this.LogMessage(this.#namespace[namespace], `${namespace}: Socket connected, ID: [${socket.id}]`);
-      this.LogMessage(this.#namespace[namespace], `${namespace}: Authentication Handshake: [${JSON.stringify(socket.handshake.auth)}]`);
-      this.#SetupMessageMiddleware(socket);
-      if (autoJoinRooms) {
-        rooms.map((room) => {
-          this.JoinRoom(this.#namespace[namespace], socket, room);
-        });
-      }
-      this.#SetupStandardEvents(this.#namespace[namespace], socket);
-      if (socketConnectCallBack) {
+  SetupNamespace = (rooms, autoJoinRooms) => {
+    if (this.io) {
+      this.socketionamespace = this.io.of(`/${this.namespace}/`);
+      this.SetupConnectionMiddleware();
+      this.socketionamespace.on("connection", (socket) => {
+        this.LogDebugMessage(`Socket connected, ID: [${socket.id}]`);
+        this.LogDebugMessage(`Authentication Handshake (auth): [${JSON.stringify(socket.handshake.auth)}]`);
+        this.LogDebugMessage(`Authentication Handshake (host): [${JSON.stringify(socket.handshake.headers.host)}]`);
+        this.LogDebugMessage(`Authentication Handshake (url): [${JSON.stringify(socket.handshake.url)}]`);
+        this.LogDebugMessage(`Authentication Handshake: [${JSON.stringify(socket.handshake)}]`);
+        this.SetupMessageMiddleware(socket);
+        if (autoJoinRooms) {
+          rooms.map((room) => {
+            this.JoinRoom(socket, room);
+          });
+        }
+        this.SetupStandardEvents(socket);
         setTimeout(() => {
-          socketConnectCallBack(socket);
+          this.SocketConnectCallBack(socket);
         }, 0);
-      }
-      if (socketEventsCallBack) {
-        socketEventsCallBack(socket);
-      }
-    });
-    return this.#namespace[namespace].socketionamespace;
-  };
-  GetSTSSocketIONamespace = (namespace) => {
-    return this.#namespace[namespace];
-  };
-  GetSTSSocketIONamespaces = () => {
-    return this.#namespace;
+        this.SocketEventsCallBack(socket);
+      });
+    } else {
+      throw new Error("SocketIoServer:SetupNamespace(): Error: [No server attached");
+    }
+    return this;
   };
-  CloseAdaptors = async () => {
-    for (const [, namespace] of Object.entries(this.#namespace)) {
-      await namespace.socketionamespace.adapter.close();
+  CloseNamespaceAdaptors = async () => {
+    if (this.socketionamespace) {
+      await this.socketionamespace.adapter.close();
     }
   };
-  DisconnectSockets = () => {
-    for (const [, namespace] of Object.entries(this.#namespace)) {
-      namespace.socketionamespace.disconnectSockets();
+  DisconnectNamespaceSockets = () => {
+    if (this.socketionamespace) {
+      this.socketionamespace.disconnectSockets();
+      this.socketionamespace = void 0;
     }
-    this.#namespace = {};
   };
-  SetupEvent(event, eventCb) {
-    return this;
-  }
 }
 export {
   STSEvent,
   STSNamespace,
   STSRoom,
   SocketIoClient,
-  SocketIoServerHelper
+  SocketIoServer
 };
 //# sourceMappingURL=stssocketioutils.mjs.map