@rljson/bs 0.0.19 → 0.0.20

package/dist/bs.js

@@ -740,21 +740,23 @@ class BsPeerBridge {
     this._socket = _socket;
   }
   _eventHandlers = /* @__PURE__ */ new Map();
+  _handleConnectBound = this._handleConnect.bind(this);
+  _handleDisconnectBound = this._handleDisconnect.bind(this);
   /**
    * Starts the bridge by setting up connection event handlers and
    * automatically registering all Bs methods.
    */
   start() {
-    this._socket.on("connect", () => this._handleConnect());
-    this._socket.on("disconnect", () => this._handleDisconnect());
+    this._socket.on("connect", this._handleConnectBound);
+    this._socket.on("disconnect", this._handleDisconnectBound);
     this._registerBsMethods();
   }
   /**
    * Stops the bridge by removing all event handlers.
    */
   stop() {
-    this._socket.off("connect", () => this._handleConnect());
-    this._socket.off("disconnect", () => this._handleDisconnect());
+    this._socket.off("connect", this._handleConnectBound);
+    this._socket.off("disconnect", this._handleDisconnectBound);
     for (const [eventName, handler] of this._eventHandlers) {
       this._socket.off(eventName, handler);
     }
@@ -765,14 +767,11 @@ class BsPeerBridge {
    */
   _registerBsMethods() {
     const bsMethods = [
-      "setBlob",
       "getBlob",
       "getBlobStream",
-      "deleteBlob",
       "blobExists",
       "getBlobProperties",
-      "listBlobs",
-      "generateSignedUrl"
+      "listBlobs"
     ];
     for (const methodName of bsMethods) {
       this.registerEvent(methodName);
@@ -794,17 +793,17 @@ class BsPeerBridge {
           `Method "${methodName}" not found on Bs instance`
         );
         if (typeof callback === "function") {
-          callback(null, error);
+          callback(error, null);
         }
         return;
       }
       bsMethod.apply(this._bs, methodArgs).then((result) => {
         if (typeof callback === "function") {
-          callback(result, null);
+          callback(null, result);
         }
       }).catch((error) => {
         if (typeof callback === "function") {
-          callback(null, error);
+          callback(error, null);
         }
       });
     };
@@ -852,9 +851,9 @@ class BsPeerBridge {
         throw new Error(`Method "${bsMethodName}" not found on Bs instance`);
       }
       const result = await bsMethod.apply(this._bs, args);
-      this._socket.emit(socketEventName, result, null);
+      this._socket.emit(socketEventName, null, result);
     } catch (error) {
-      this._socket.emit(socketEventName, null, error);
+      this._socket.emit(socketEventName, error, null);
     }
   }
   /* v8 ignore next -- @preserve */
@@ -1075,6 +1074,155 @@ 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.
+   * @param eventName - The event name to emit
+   * @param args - Arguments to pass with the event
+   */
+  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.
+   * @param eventName - The event name to trigger
+   * @param args - Arguments to pass to the listeners
+   */
+  _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);
+  }
+}
 export {
   BsMem,
   BsMulti,
@@ -1082,5 +1230,6 @@ export {
   BsPeerBridge,
   BsServer,
   PeerSocketMock,
-  SocketMock
+  SocketMock,
+  createSocketPair
 };

package/dist/directional-socket-mock.d.ts

@@ -0,0 +1,10 @@
+import { Socket } from './socket.ts';
+/**
+ * Creates a pair of connected sockets that properly route messages between them.
+ * Unlike SocketMock, this maintains directionality - when socketA emits, only socketB's
+ * listeners fire, not socketA's own listeners.
+ *
+ * This is essential for client-server testing where both use the same socket instance
+ * but need separate event handling.
+ */
+export declare function createSocketPair(): [Socket, Socket];

package/dist/index.d.ts

@@ -7,4 +7,5 @@ export type { BsTestSetup } from './bs-test-setup.js';
 export type { BlobProperties, Bs, DownloadBlobOptions, ListBlobsOptions, ListBlobsResult, } from './bs.js';
 export { PeerSocketMock } from './peer-socket-mock.js';
 export { SocketMock } from './socket-mock.js';
+export { createSocketPair } from './directional-socket-mock.js';
 export type { Socket } from './socket.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rljson/bs",
-  "version": "0.0.19",
+  "version": "0.0.20",
   "description": "Blob storage interface and implementations for rljson",
   "homepage": "https://github.com/rljson/bs",
   "bugs": "https://github.com/rljson/bs/issues",
@@ -20,30 +20,30 @@
   ],
   "type": "module",
   "devDependencies": {
-    "@types/node": "^25.0.10",
-    "@typescript-eslint/eslint-plugin": "^8.53.1",
-    "@typescript-eslint/parser": "^8.53.1",
-    "@vitest/coverage-v8": "^4.0.17",
+    "@types/node": "^25.1.0",
+    "@typescript-eslint/eslint-plugin": "^8.54.0",
+    "@typescript-eslint/parser": "^8.54.0",
+    "@vitest/coverage-v8": "^4.0.18",
     "cross-env": "^10.1.0",
     "eslint": "^9.39.2",
-    "eslint-plugin-jsdoc": "^62.3.0",
+    "eslint-plugin-jsdoc": "^62.5.0",
     "eslint-plugin-tsdoc": "^0.5.0",
-    "globals": "^17.0.0",
+    "globals": "^17.2.0",
     "jsdoc": "^4.0.5",
     "read-pkg": "^10.0.0",
     "typescript": "~5.9.3",
-    "typescript-eslint": "^8.53.1",
+    "typescript-eslint": "^8.54.0",
     "vite": "^7.3.1",
     "vite-node": "^5.3.0",
     "vite-plugin-dts": "^4.5.4",
-    "vite-tsconfig-paths": "^6.0.4",
-    "vitest": "^4.0.17",
+    "vite-tsconfig-paths": "^6.0.5",
+    "vitest": "^4.0.18",
     "vitest-dom": "^0.1.1"
   },
   "dependencies": {
     "@rljson/hash": "^0.0.18",
     "@rljson/json": "^0.0.23",
-    "@rljson/rljson": "^0.0.74"
+    "@rljson/rljson": "^0.0.75"
   },
   "scripts": {
     "build": "pnpx vite build && tsc && node scripts/copy-readme-to-dist.js && node scripts/deploy-conformance-tests.js",