@peers-app/peers-sdk 0.14.0 → 0.15.0

package/dist/device/socket-io-binary-peer.js

@@ -11,7 +11,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wrapSocketIOAsBinaryPeer = wrapSocketIOAsBinaryPeer;
 // Event name for binary data transfer
-const BINARY_EVENT = '_bin';
+const BINARY_EVENT = "_bin";
 /**
  * Wraps a socket.io socket (client or server) as an IBinaryPeer.
  * This allows websocket connections to use the same binary protocol
@@ -26,40 +26,40 @@ function wrapSocketIOAsBinaryPeer(socket) {
     socket.on(BINARY_EVENT, (data) => {
         // Ensure we have a proper Uint8Array
         const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
-        dataHandlers.forEach(handler => {
+        dataHandlers.forEach((handler) => {
             try {
                 handler(bytes);
             }
             catch (err) {
-                console.error('[socket-io-binary] Error in data handler:', err);
+                console.error("[socket-io-binary] Error in data handler:", err);
             }
         });
     });
     // Listen for disconnect
-    socket.on('disconnect', () => {
-        closeHandlers.forEach(handler => {
+    socket.on("disconnect", () => {
+        closeHandlers.forEach((handler) => {
             try {
                 handler();
             }
             catch (err) {
-                console.error('[socket-io-binary] Error in close handler:', err);
+                console.error("[socket-io-binary] Error in close handler:", err);
             }
         });
     });
     return {
         on(event, handler) {
-            if (event === 'data') {
+            if (event === "data") {
                 dataHandlers.push(handler);
             }
-            else if (event === 'close') {
+            else if (event === "close") {
                 closeHandlers.push(handler);
             }
-            else if (event === 'drain') {
+            else if (event === "drain") {
                 drainHandlers.push(handler);
             }
         },
         send(data) {
-            const bytes = typeof data === 'string'
+            const bytes = typeof data === "string"
                 ? Buffer.from(data)
                 : data instanceof Uint8Array
                     ? data
@@ -70,8 +70,11 @@ function wrapSocketIOAsBinaryPeer(socket) {
             // Simulate drain after send completes
             setImmediate(() => {
                 pendingBytes = Math.max(0, pendingBytes - bytes.length);
-                if (pendingBytes < 1024 * 1024) { // Under 1MB
-                    drainHandlers.forEach(h => h());
+                if (pendingBytes < 1024 * 1024) {
+                    // Under 1MB
+                    drainHandlers.forEach((h) => {
+                        h();
+                    });
                 }
             });
         },
@@ -92,6 +95,6 @@ function wrapSocketIOAsBinaryPeer(socket) {
                 }, 0);
             }
             return pendingBytes;
-        }
+        },
     };
 }

package/dist/device/socket.type.d.ts

@@ -16,7 +16,7 @@ export interface ISocketStats {
 }
 /** Creates a new stats object for tracking socket throughput */
 export declare function createSocketStats(): ISocketStats;
-export type TransportType = 'ws' | 'wrtc' | 'unknown';
+export type TransportType = "ws" | "wrtc" | "unknown";
 export interface ISocket {
     id?: string;
     connected?: boolean;
@@ -36,7 +36,7 @@ export interface ISocket {
      */
     stats?: ISocketStats;
     emit(eventName: string, args: any, callback: RPCCallback): void;
-    on(eventName: string, handler: ((...args: any[]) => void)): void;
+    on(eventName: string, handler: (...args: any[]) => void): void;
     removeAllListeners(eventName?: string): void;
     disconnect(close?: boolean): void;
     /**

package/dist/device/streamed-socket.d.ts

@@ -1,4 +1,4 @@
-import { ISocket, ISocketStats, RPCCallback } from "./socket.type";
+import { type ISocket, type ISocketStats, type RPCCallback } from "./socket.type";
 /** Creates a new stats object for tracking socket throughput */
 export declare function createSocketStats(): ISocketStats;
 export declare class StreamedSocket implements ISocket {
@@ -14,7 +14,7 @@ export declare class StreamedSocket implements ISocket {
     private readonly callbacks;
     emit(eventName: string, args: any, callback: RPCCallback): void;
     private handlers;
-    on(eventName: string, handler: ((...args: any[]) => void)): void;
+    on(eventName: string, handler: (...args: any[]) => void): void;
     removeAllListeners(eventName: string): void;
     private readonly chunkBuffers;
     private handleChunk;

package/dist/device/streamed-socket.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamedSocket = void 0;
 exports.createSocketStats = createSocketStats;
+const msgpack_1 = require("@msgpack/msgpack");
 const lodash_1 = require("lodash");
 const utils_1 = require("../utils");
 const socket_type_1 = require("./socket.type");
 const tx_encoding_1 = require("./tx-encoding");
-const msgpack_1 = require("@msgpack/msgpack");
 /** Creates a new stats object for tracking socket throughput */
 function createSocketStats() {
     const now = Date.now();
@@ -75,8 +75,8 @@ function decodeChunk(bytes) {
 class StreamedSocket {
     socket;
     maxChunkSize;
-    safeSocketChunkEventName = '__streamed-socket-chunk';
-    safeSocketResponseEventName = '__streamed-socket-response';
+    safeSocketChunkEventName = "__streamed-socket-chunk";
+    safeSocketResponseEventName = "__streamed-socket-response";
     stats = createSocketStats();
     constructor(socket, maxChunkSize = socket_type_1.DEFAULT_MAX_CHUNK_SIZE) {
         this.socket = socket;
@@ -112,7 +112,7 @@ class StreamedSocket {
         const chunks = [];
         // Reserve space for metadata overhead (typically ~50-100 bytes)
         const metadataOverhead = 128;
-        if (this.maxChunkSize < (metadataOverhead * 2)) {
+        if (this.maxChunkSize < metadataOverhead * 2) {
             throw new Error(`maxChunkSize ${this.maxChunkSize} is too small to accommodate metadata overhead, must be greater than ${metadataOverhead * 2}`);
         }
         const effectiveChunkSize = this.maxChunkSize - metadataOverhead;
@@ -206,8 +206,8 @@ class StreamedSocket {
             if (!handler) {
                 throw new Error(`No handler registered for event ${eventName}`);
             }
-            let error = undefined;
-            let result = undefined;
+            let error;
+            let result;
             try {
                 await new Promise((resolve) => {
                     handler(args, (...params) => {
@@ -222,11 +222,11 @@ class StreamedSocket {
             this.emit(this.safeSocketResponseEventName, {
                 messageId: chunkZero.messageId,
                 error,
-                result
+                result,
             }, lodash_1.noop);
         }
         catch (error) {
-            if (String(error).includes('No handler registered for event')) {
+            if (String(error).includes("No handler registered for event")) {
                 console.warn(String(error));
             }
             else {

package/dist/device/streamed-socket.test.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const streamed_socket_1 = require("./streamed-socket");
+const msgpack_1 = require("@msgpack/msgpack");
 const utils_1 = require("../utils");
+const streamed_socket_1 = require("./streamed-socket");
 const tx_encoding_1 = require("./tx-encoding");
-const msgpack_1 = require("@msgpack/msgpack");
 // Helper to decode the binary chunk format
 function decodeChunk(bytes) {
     const view = new DataView(bytes.buffer, bytes.byteOffset);
@@ -20,10 +20,10 @@ function createMockSocket() {
         emit(eventName, args, callback) {
             emittedEvents.push({ eventName, args, callback });
         },
-        on(eventName, handler) {
+        on(_eventName, _handler) {
             // Simple mock - we'll manually trigger events in tests
         },
-        removeAllListeners(eventName) {
+        removeAllListeners(_eventName) {
             // Simple mock
         },
         disconnect() {
@@ -32,20 +32,20 @@ function createMockSocket() {
     };
     return {
         socket,
-        getEmittedEvents: () => emittedEvents
+        getEmittedEvents: () => emittedEvents,
     };
 }
-describe('StreamedSocket', () => {
-    it('should emit a single chunk for small messages', () => {
+describe("StreamedSocket", () => {
+    it("should emit a single chunk for small messages", () => {
         const mock = createMockSocket();
         const streamedSocket = new streamed_socket_1.StreamedSocket(mock.socket, 1000); // Large chunk size
-        const testData = { message: 'hello' };
-        streamedSocket.emit('test-event', testData, () => { });
+        const testData = { message: "hello" };
+        streamedSocket.emit("test-event", testData, () => { });
         // Should emit a single chunk
         const emittedEvents = mock.getEmittedEvents();
         expect(emittedEvents).toHaveLength(1);
         const chunkEvent = emittedEvents[0];
-        expect(chunkEvent.eventName).toBe('__streamed-socket-chunk');
+        expect(chunkEvent.eventName).toBe("__streamed-socket-chunk");
         // Args should be a Uint8Array (binary encoded chunk)
         expect(chunkEvent.args).toBeInstanceOf(Uint8Array);
         // Decode the binary chunk
@@ -53,36 +53,36 @@ describe('StreamedSocket', () => {
         expect(decodedChunk.messageId).toBeTruthy();
         expect(decodedChunk.chunkIndex).toBe(0);
         expect(decodedChunk.totalChunks).toBe(1);
-        expect(decodedChunk.eventName).toBe('test-event');
+        expect(decodedChunk.eventName).toBe("test-event");
         // Decode the actual data
         const decoded = (0, tx_encoding_1.txDecode)(decodedChunk.data);
         expect(decoded).toEqual(testData);
     });
-    it('should emit multiple chunks for large messages', () => {
+    it("should emit multiple chunks for large messages", () => {
         const mock = createMockSocket();
         const streamedSocket = new streamed_socket_1.StreamedSocket(mock.socket, 256); // Small chunk size to force chunking
         // Create a large test object
         const testData = {
-            message: 'x'.repeat(200),
+            message: "x".repeat(200),
             array: [1, 2, 3, 4, 5],
-            nested: { deep: 'value' }
+            nested: { deep: "value" },
         };
-        streamedSocket.emit('test-event', testData, () => { });
+        streamedSocket.emit("test-event", testData, () => { });
         const emittedEvents = mock.getEmittedEvents();
         expect(emittedEvents.length).toBeGreaterThan(1);
         // Decode all chunks
-        const decodedChunks = emittedEvents.map(event => {
+        const decodedChunks = emittedEvents.map((event) => {
             expect(event.args).toBeInstanceOf(Uint8Array);
             return decodeChunk(event.args);
         });
         // Verify first chunk has metadata
         const firstChunk = decodedChunks[0];
-        expect(firstChunk.eventName).toBe('test-event');
+        expect(firstChunk.eventName).toBe("test-event");
         expect(firstChunk.totalChunks).toBe(emittedEvents.length);
         expect(firstChunk.chunkIndex).toBe(0);
         // Verify all chunks have the same messageId
         const messageId = firstChunk.messageId;
-        decodedChunks.forEach(chunk => {
+        decodedChunks.forEach((chunk) => {
             expect(chunk.messageId).toBe(messageId);
         });
         // Verify chunks are in order
@@ -90,7 +90,7 @@ describe('StreamedSocket', () => {
             expect(chunk.chunkIndex).toBe(index);
         });
         // Verify all chunk data are Uint8Arrays
-        decodedChunks.forEach(chunk => {
+        decodedChunks.forEach((chunk) => {
             expect(chunk.data).toBeInstanceOf(Uint8Array);
         });
         // Reassemble chunks and verify data integrity
@@ -103,14 +103,14 @@ describe('StreamedSocket', () => {
         const decoded = (0, tx_encoding_1.txDecode)(reassembled);
         expect(decoded).toEqual(testData);
     });
-    it('should handle binary data in messages', () => {
+    it("should handle binary data in messages", () => {
         const mock = createMockSocket();
         const streamedSocket = new streamed_socket_1.StreamedSocket(mock.socket, 1000);
         const testData = {
             binaryData: new Uint8Array([1, 2, 3, 4, 5]),
-            metadata: { name: 'test' }
+            metadata: { name: "test" },
         };
-        streamedSocket.emit('test-event', testData, () => { });
+        streamedSocket.emit("test-event", testData, () => { });
         const emittedEvents = mock.getEmittedEvents();
         expect(emittedEvents).toHaveLength(1);
         const decodedChunk = decodeChunk(emittedEvents[0].args);
@@ -119,29 +119,29 @@ describe('StreamedSocket', () => {
         expect(decoded.binaryData).toEqual(testData.binaryData);
         expect(decoded.metadata).toEqual(testData.metadata);
     });
-    it('should handle special types in messages', () => {
+    it("should handle special types in messages", () => {
         const mock = createMockSocket();
         const streamedSocket = new streamed_socket_1.StreamedSocket(mock.socket, 1000);
         const testData = {
-            date: new Date('2023-01-01T00:00:00.000Z'),
+            date: new Date("2023-01-01T00:00:00.000Z"),
             nan: NaN,
             infinity: Infinity,
             undef: undefined,
-            nullVal: null
+            nullVal: null,
         };
-        streamedSocket.emit('test-event', testData, () => { });
+        streamedSocket.emit("test-event", testData, () => { });
         const emittedEvents = mock.getEmittedEvents();
         expect(emittedEvents).toHaveLength(1);
         const decodedChunk = decodeChunk(emittedEvents[0].args);
         const decoded = (0, tx_encoding_1.txDecode)(decodedChunk.data);
         expect(decoded.date).toBeInstanceOf(Date);
-        expect(decoded.date.toISOString()).toBe('2023-01-01T00:00:00.000Z');
+        expect(decoded.date.toISOString()).toBe("2023-01-01T00:00:00.000Z");
         expect(Number.isNaN(decoded.nan)).toBe(true);
         expect(decoded.infinity).toBe(Infinity);
         expect(decoded.undef).toBeUndefined();
         expect(decoded.nullVal).toBeNull();
     });
-    it('should demonstrate msgpack efficiency: structured data vs JSON string (uncompressed)', () => {
+    it("should demonstrate msgpack efficiency: structured data vs JSON string (uncompressed)", () => {
         const mock1 = createMockSocket();
         const mock2 = createMockSocket();
         const streamedSocket1 = new streamed_socket_1.StreamedSocket(mock1.socket, 1000000); // Large chunk to avoid splitting
@@ -154,15 +154,15 @@ describe('StreamedSocket', () => {
                 email: `user${i}@example.com`,
                 score: Math.random() * 1000,
                 active: i % 2 === 0,
-            }))
+            })),
         };
         // Convert to JSON string
         const jsonString = JSON.stringify(smallObject);
         console.log(`Original JSON string size: ${jsonString.length} bytes`);
         // Send as structured object (msgpack can optimize)
-        streamedSocket1.emit('test-object', smallObject, () => { });
+        streamedSocket1.emit("test-object", smallObject, () => { });
         // Send as JSON string (msgpack treats it as opaque string)
-        streamedSocket2.emit('test-string', { jsonPayload: jsonString }, () => { });
+        streamedSocket2.emit("test-string", { jsonPayload: jsonString }, () => { });
         const objectEvents = mock1.getEmittedEvents();
         const stringEvents = mock2.getEmittedEvents();
         expect(objectEvents).toHaveLength(1);
@@ -186,22 +186,22 @@ describe('StreamedSocket', () => {
         expect(decodedObject.users).toHaveLength(5);
         expect(decodedString.jsonPayload).toBe(jsonString);
     });
-    it('should demonstrate compression effectiveness for large repetitive data', () => {
+    it("should demonstrate compression effectiveness for large repetitive data", () => {
         const mock = createMockSocket();
         const streamedSocket = new streamed_socket_1.StreamedSocket(mock.socket, 1000000);
         // Create large repetitive object that will compress well
         const largeObject = {
             data: Array.from({ length: 200 }, () => ({
-                type: 'event',
-                status: 'active',
-                category: 'user_action',
-                timestamp: new Date('2024-01-01'),
-                metadata: { app: 'test', version: '1.0.0' }
-            }))
+                type: "event",
+                status: "active",
+                category: "user_action",
+                timestamp: new Date("2024-01-01"),
+                metadata: { app: "test", version: "1.0.0" },
+            })),
         };
         const jsonString = JSON.stringify(largeObject);
         console.log(`Large repetitive data - JSON size: ${jsonString.length} bytes`);
-        streamedSocket.emit('test-compressed', largeObject, () => { });
+        streamedSocket.emit("test-compressed", largeObject, () => { });
         const events = mock.getEmittedEvents();
         const chunk = decodeChunk(events[0].args);
         console.log(`After msgpack + compression: ${chunk.data.length} bytes`);
@@ -211,6 +211,6 @@ describe('StreamedSocket', () => {
         // Verify data integrity
         const decoded = (0, tx_encoding_1.txDecode)(chunk.data);
         expect(decoded.data).toHaveLength(200);
-        expect(decoded.data[0].type).toBe('event');
+        expect(decoded.data[0].type).toBe("event");
     });
 });