@rljson/io 0.0.63 → 0.0.65

package/dist/io.js

@@ -1671,6 +1671,151 @@ class SocketMock {
     return new Map(this._onceListeners);
   }
 }
+function createSocketPair() {
+  const socketA = new DirectionalSocketMock();
+  const socketB = new DirectionalSocketMock();
+  socketA._setPeer(socketB);
+  socketB._setPeer(socketA);
+  return [socketA, socketB];
+}
+class DirectionalSocketMock {
+  connected = false;
+  disconnected = true;
+  _peer;
+  _listeners = /* @__PURE__ */ new Map();
+  _onceListeners = /* @__PURE__ */ new Map();
+  _setPeer(peer) {
+    this._peer = peer;
+  }
+  connect() {
+    if (!this.connected) {
+      this.connected = true;
+      this.disconnected = false;
+      this._triggerLocal("connect");
+      if (this._peer) {
+        this._peer._triggerLocal("connect");
+      }
+    }
+  }
+  disconnect() {
+    if (this.connected) {
+      this.connected = false;
+      this.disconnected = true;
+      this._triggerLocal("disconnect");
+      if (this._peer) {
+        this._peer._triggerLocal("disconnect");
+      }
+    }
+  }
+  on(eventName, listener) {
+    if (!this._listeners.has(eventName)) {
+      this._listeners.set(eventName, []);
+    }
+    this._listeners.get(eventName).push(listener);
+    return this;
+  }
+  once(eventName, listener) {
+    if (!this._onceListeners.has(eventName)) {
+      this._onceListeners.set(eventName, []);
+    }
+    this._onceListeners.get(eventName).push(listener);
+    return this;
+  }
+  off(eventName, listener) {
+    if (listener) {
+      const regularListeners = this._listeners.get(eventName);
+      if (regularListeners) {
+        const index = regularListeners.indexOf(listener);
+        if (index > -1) regularListeners.splice(index, 1);
+      }
+      const onceListeners = this._onceListeners.get(eventName);
+      if (onceListeners) {
+        const index = onceListeners.indexOf(listener);
+        if (index > -1) onceListeners.splice(index, 1);
+      }
+    } else {
+      this._listeners.delete(eventName);
+      this._onceListeners.delete(eventName);
+    }
+    return this;
+  }
+  /**
+   * Emits an event to the PEER socket (cross-socket emission).
+   * This is the key difference from SocketMock - emit() sends to the other side,
+   * not to local listeners.
+   *
+   * Implements Socket.IO acknowledgement pattern: the last argument can be a callback
+   * that the peer will invoke to send a response back.
+   */
+  emit(eventName, ...args) {
+    if (!this._peer) {
+      console.warn(
+        `DirectionalSocketMock.emit: No peer connected for event ${String(eventName)}`
+      );
+      return false;
+    }
+    this._peer._triggerLocal(eventName, ...args);
+    return true;
+  }
+  /**
+   * Triggers listeners on THIS socket (local emission).
+   * Used internally when receiving events from peer.
+   */
+  _triggerLocal(eventName, ...args) {
+    const regularListeners = this._listeners.get(eventName);
+    if (regularListeners) {
+      [...regularListeners].forEach((listener) => {
+        try {
+          listener(...args);
+        } catch (error) {
+          console.error(`Error in listener for ${String(eventName)}:`, error);
+        }
+      });
+    }
+    const onceListeners = this._onceListeners.get(eventName);
+    if (onceListeners) {
+      const listenersToCall = [...onceListeners];
+      this._onceListeners.delete(eventName);
+      listenersToCall.forEach((listener) => {
+        try {
+          listener(...args);
+        } catch (error) {
+          console.error(
+            `Error in once listener for ${String(eventName)}:`,
+            error
+          );
+        }
+      });
+    }
+  }
+  removeAllListeners(eventName) {
+    if (eventName !== void 0) {
+      this._listeners.delete(eventName);
+      this._onceListeners.delete(eventName);
+    } else {
+      this._listeners.clear();
+      this._onceListeners.clear();
+    }
+    return this;
+  }
+  listenerCount(eventName) {
+    const regularCount = this._listeners.get(eventName)?.length || 0;
+    const onceCount = this._onceListeners.get(eventName)?.length || 0;
+    return regularCount + onceCount;
+  }
+  listeners(eventName) {
+    const regularListeners = this._listeners.get(eventName) || [];
+    const onceListeners = this._onceListeners.get(eventName) || [];
+    return [...regularListeners, ...onceListeners];
+  }
+  eventNames() {
+    const allEvents = /* @__PURE__ */ new Set([
+      ...this._listeners.keys(),
+      ...this._onceListeners.keys()
+    ]);
+    return Array.from(allEvents);
+  }
+}
 const socketExample = () => ({
   connected: false,
   disconnected: true,
@@ -1702,6 +1847,7 @@ const socketExample = () => ({
   }
 });
 export {
+  DirectionalSocketMock,
   IoDbNameMapping,
   IoMem,
   IoMulti,
@@ -1712,6 +1858,7 @@ export {
   PeerSocketMock,
   SocketMock,
   calcReverseRefs,
+  createSocketPair,
   exampleIo,
   exampleTestSetup,
   socketExample