@peers-app/peers-sdk 0.27.3 → 0.27.5

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

@@ -1,23 +0,0 @@
-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 {
-    readonly socket: ISocket;
-    maxChunkSize: number;
-    readonly safeSocketChunkEventName = "__streamed-socket-chunk";
-    readonly safeSocketResponseEventName = "__streamed-socket-response";
-    readonly stats: ISocketStats;
-    constructor(socket: ISocket, maxChunkSize?: number);
-    get id(): string | undefined;
-    get connected(): boolean | undefined;
-    disconnect(close?: boolean): void;
-    private readonly callbacks;
-    emit(eventName: string, args: any, callback: RPCCallback): void;
-    private handlers;
-    on(eventName: string, handler: (...args: any[]) => void): void;
-    removeAllListeners(eventName: string): void;
-    private readonly chunkBuffers;
-    private handleChunk;
-    private processChunks;
-    private handleResponse;
-}

package/dist/device/streamed-socket.js

@@ -1,255 +0,0 @@
-"use strict";
-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");
-/** Creates a new stats object for tracking socket throughput */
-function createSocketStats() {
-    const now = Date.now();
-    return {
-        bytesSent: 0,
-        bytesReceived: 0,
-        messagesSent: 0,
-        messagesReceived: 0,
-        startTime: now,
-        // For calculating recent rates
-        lastSampleTime: now,
-        lastSampleBytesSent: 0,
-        lastSampleBytesReceived: 0,
-    };
-}
-// Encode chunk metadata + data into a single Uint8Array
-function encodeChunk(chunk) {
-    // Encode metadata using msgpack
-    const metadata = {
-        messageId: chunk.messageId,
-        chunkIndex: chunk.chunkIndex,
-        ...(chunk.totalChunks !== undefined && { totalChunks: chunk.totalChunks }),
-        ...(chunk.eventName !== undefined && { eventName: chunk.eventName }),
-    };
-    const metadataBytes = (0, msgpack_1.encode)(metadata);
-    const metadataLength = metadataBytes.length;
-    // Create combined buffer: [4 bytes length][metadata][data]
-    const combined = new Uint8Array(4 + metadataLength + chunk.data.length);
-    // Write metadata length as 32-bit unsigned integer (big-endian)
-    const view = new DataView(combined.buffer, combined.byteOffset, combined.byteLength);
-    view.setUint32(0, metadataLength, false); // big-endian
-    // Write metadata
-    combined.set(metadataBytes, 4);
-    // Write data
-    combined.set(chunk.data, 4 + metadataLength);
-    return combined;
-}
-// Decode binary chunk back into IMessageChunk
-function decodeChunk(bytes) {
-    // Ensure we have a proper Uint8Array with a valid ArrayBuffer
-    // Socket.io might send data that doesn't have a proper buffer property
-    let normalizedBytes;
-    if (bytes.buffer instanceof ArrayBuffer) {
-        normalizedBytes = bytes;
-    }
-    else {
-        // Create a new Uint8Array copy which will have a proper buffer
-        normalizedBytes = new Uint8Array(bytes);
-    }
-    // Read metadata length
-    const view = new DataView(normalizedBytes.buffer, normalizedBytes.byteOffset, normalizedBytes.byteLength);
-    const metadataLength = view.getUint32(0, false); // big-endian
-    // Extract metadata
-    const metadataBytes = normalizedBytes.subarray(4, 4 + metadataLength);
-    const metadata = (0, msgpack_1.decode)(metadataBytes);
-    // Extract data
-    const data = normalizedBytes.subarray(4 + metadataLength);
-    return {
-        messageId: metadata.messageId,
-        chunkIndex: metadata.chunkIndex,
-        totalChunks: metadata.totalChunks,
-        eventName: metadata.eventName,
-        data: data,
-    };
-}
-class StreamedSocket {
-    socket;
-    maxChunkSize;
-    safeSocketChunkEventName = "__streamed-socket-chunk";
-    safeSocketResponseEventName = "__streamed-socket-response";
-    stats = createSocketStats();
-    constructor(socket, maxChunkSize = socket_type_1.DEFAULT_MAX_CHUNK_SIZE) {
-        this.socket = socket;
-        this.maxChunkSize = maxChunkSize;
-        socket.on(this.safeSocketChunkEventName, (encodedChunk) => {
-            // Track received bytes
-            this.stats.bytesReceived += encodedChunk.length;
-            const chunk = decodeChunk(encodedChunk);
-            this.handleChunk(chunk);
-        });
-    }
-    get id() {
-        return this.socket.id;
-    }
-    get connected() {
-        return this.socket.connected;
-    }
-    disconnect(close) {
-        this.socket.disconnect(close);
-    }
-    callbacks = {};
-    emit(eventName, args, callback) {
-        const encoded = (0, tx_encoding_1.txEncode)(args);
-        // if (encoded.length < this.maxChunkSize) {
-        //   // If the data is small enough, send it directly
-        //   this.socket.emit(eventName, args, callback);
-        //   return;
-        // }
-        const messageId = (0, utils_1.newid)();
-        if (callback !== lodash_1.noop) {
-            this.callbacks[messageId] = callback;
-        }
-        const chunks = [];
-        // Reserve space for metadata overhead (typically ~50-100 bytes)
-        const metadataOverhead = 128;
-        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;
-        for (let i = 0; i < encoded.length; i += effectiveChunkSize) {
-            const chunkData = encoded.subarray(i, i + effectiveChunkSize);
-            chunks.push({
-                messageId,
-                chunkIndex: Math.floor(i / effectiveChunkSize),
-                data: chunkData,
-            });
-            if (i === 0) {
-                // The first chunk contains metadata about the chunks
-                chunks[0].eventName = eventName;
-                chunks[0].totalChunks = Math.ceil(encoded.length / effectiveChunkSize);
-            }
-        }
-        if (chunks.length > 1) {
-            console.debug(`Sending ${chunks.length} chunks for event ${eventName} with messageId ${messageId}`);
-        }
-        let totalBytesSent = 0;
-        for (const chunk of chunks) {
-            // Encode chunk with metadata into single Uint8Array
-            const encodedChunk = encodeChunk(chunk);
-            totalBytesSent += encodedChunk.length;
-            // TODO on error or timeout retry
-            // TODO respond to backpressure from socket
-            this.socket.emit(this.safeSocketChunkEventName, encodedChunk, lodash_1.noop);
-        }
-        // Track stats
-        this.stats.bytesSent += totalBytesSent;
-        this.stats.messagesSent++;
-    }
-    handlers = {};
-    on(eventName, handler) {
-        this.handlers[eventName] = handler;
-        // TODO I think this needs to come back to a handleResult method on this class
-        this.socket.on(eventName, handler);
-    }
-    removeAllListeners(eventName) {
-        this.socket.removeAllListeners(eventName);
-        delete this.handlers[eventName];
-    }
-    chunkBuffers = {};
-    async handleChunk(chunk) {
-        if (!this.chunkBuffers[chunk.messageId]) {
-            // TODO handle timeout for chunks and cleanup data to prevent memory leaks
-            this.chunkBuffers[chunk.messageId] = [];
-        }
-        const chunks = this.chunkBuffers[chunk.messageId];
-        const chunkIndex = chunk.chunkIndex;
-        if (chunkIndex < 0) {
-            console.warn(`Received chunk with negative index ${chunk.chunkIndex} for messageId: ${chunk.messageId}`, chunk);
-            return;
-        }
-        chunks[chunkIndex] = chunk;
-        const chunkZero = chunks[0];
-        if (!chunkZero && chunks.length > 100) {
-            console.error(`Received over 100 chunks without a chunkZero for messageId: ${chunk.messageId}. This could indicate a memory attack`, chunk);
-        }
-        if (chunkZero) {
-            if (chunkZero?.totalChunks <= chunkIndex) {
-                console.warn(`Received chunk with index ${chunk.chunkIndex} which is greater than totalChunks ${chunkZero.totalChunks} for messageId: ${chunk.messageId}`, chunk);
-                return;
-            }
-            if (chunks.length >= chunkZero.totalChunks) {
-                this.processChunks(chunks);
-            }
-        }
-    }
-    async processChunks(chunks) {
-        try {
-            const chunkZero = chunks[0];
-            // Reassemble Uint8Array chunks (already decoded from binary format)
-            const totalSize = chunks.reduce((sum, chunk) => sum + chunk.data.length, 0);
-            const reassembled = new Uint8Array(totalSize);
-            let offset = 0;
-            for (const chunk of chunks) {
-                reassembled.set(chunk.data, offset);
-                offset += chunk.data.length;
-            }
-            // Track message received
-            this.stats.messagesReceived++;
-            delete this.chunkBuffers[chunkZero.messageId];
-            const eventName = chunkZero.eventName;
-            const args = (0, tx_encoding_1.txDecode)(reassembled);
-            if (eventName === this.safeSocketResponseEventName) {
-                this.handleResponse(args.messageId, args.error, args.result);
-                return;
-            }
-            const handler = this.handlers[eventName];
-            if (!handler) {
-                throw new Error(`No handler registered for event ${eventName}`);
-            }
-            let error;
-            let result;
-            try {
-                await new Promise((resolve) => {
-                    handler(args, (...params) => {
-                        [error, result] = params;
-                        resolve();
-                    });
-                });
-            }
-            catch (err) {
-                error = err;
-            }
-            this.emit(this.safeSocketResponseEventName, {
-                messageId: chunkZero.messageId,
-                error,
-                result,
-            }, lodash_1.noop);
-        }
-        catch (error) {
-            if (String(error).includes("No handler registered for event")) {
-                console.warn(String(error));
-            }
-            else {
-                console.error(`Error handling chunked request:`, error);
-            }
-            return;
-        }
-    }
-    async handleResponse(messageId, error, result) {
-        const callback = this.callbacks[messageId];
-        if (!callback) {
-            console.warn(`No callback found for messageId ${messageId}`);
-        }
-        delete this.callbacks[messageId];
-        if (error) {
-            console.error(`Error in SafeSocket response for messageId ${messageId}:`, error);
-        }
-        try {
-            await callback(error, result);
-        }
-        catch (err) {
-            console.error(`Error in SafeSocket callback for messageId ${messageId}:`, err);
-        }
-    }
-}
-exports.StreamedSocket = StreamedSocket;

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,216 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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");
-// Helper to decode the binary chunk format
-function decodeChunk(bytes) {
-    const view = new DataView(bytes.buffer, bytes.byteOffset);
-    const metadataLength = view.getUint32(0, false);
-    const metadataBytes = bytes.subarray(4, 4 + metadataLength);
-    const metadata = (0, msgpack_1.decode)(metadataBytes);
-    const data = bytes.subarray(4 + metadataLength);
-    return { ...metadata, data };
-}
-function createMockSocket() {
-    const emittedEvents = [];
-    const socket = {
-        id: (0, utils_1.newid)(),
-        emit(eventName, args, callback) {
-            emittedEvents.push({ eventName, args, callback });
-        },
-        on(_eventName, _handler) {
-            // Simple mock - we'll manually trigger events in tests
-        },
-        removeAllListeners(_eventName) {
-            // Simple mock
-        },
-        disconnect() {
-            // Simple mock - we'll assume the socket is disconnected
-        },
-    };
-    return {
-        socket,
-        getEmittedEvents: () => emittedEvents,
-    };
-}
-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, () => { });
-        // Should emit a single chunk
-        const emittedEvents = mock.getEmittedEvents();
-        expect(emittedEvents).toHaveLength(1);
-        const chunkEvent = emittedEvents[0];
-        expect(chunkEvent.eventName).toBe("__streamed-socket-chunk");
-        // Args should be a Uint8Array (binary encoded chunk)
-        expect(chunkEvent.args).toBeInstanceOf(Uint8Array);
-        // Decode the binary chunk
-        const decodedChunk = decodeChunk(chunkEvent.args);
-        expect(decodedChunk.messageId).toBeTruthy();
-        expect(decodedChunk.chunkIndex).toBe(0);
-        expect(decodedChunk.totalChunks).toBe(1);
-        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", () => {
-        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),
-            array: [1, 2, 3, 4, 5],
-            nested: { deep: "value" },
-        };
-        streamedSocket.emit("test-event", testData, () => { });
-        const emittedEvents = mock.getEmittedEvents();
-        expect(emittedEvents.length).toBeGreaterThan(1);
-        // Decode all chunks
-        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.totalChunks).toBe(emittedEvents.length);
-        expect(firstChunk.chunkIndex).toBe(0);
-        // Verify all chunks have the same messageId
-        const messageId = firstChunk.messageId;
-        decodedChunks.forEach((chunk) => {
-            expect(chunk.messageId).toBe(messageId);
-        });
-        // Verify chunks are in order
-        decodedChunks.forEach((chunk, index) => {
-            expect(chunk.chunkIndex).toBe(index);
-        });
-        // Verify all chunk data are Uint8Arrays
-        decodedChunks.forEach((chunk) => {
-            expect(chunk.data).toBeInstanceOf(Uint8Array);
-        });
-        // Reassemble chunks and verify data integrity
-        const reassembled = new Uint8Array(decodedChunks.reduce((sum, chunk) => sum + chunk.data.length, 0));
-        let offset = 0;
-        for (const chunk of decodedChunks) {
-            reassembled.set(chunk.data, offset);
-            offset += chunk.data.length;
-        }
-        const decoded = (0, tx_encoding_1.txDecode)(reassembled);
-        expect(decoded).toEqual(testData);
-    });
-    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" },
-        };
-        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.binaryData).toBeInstanceOf(Uint8Array);
-        expect(decoded.binaryData).toEqual(testData.binaryData);
-        expect(decoded.metadata).toEqual(testData.metadata);
-    });
-    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"),
-            nan: NaN,
-            infinity: Infinity,
-            undef: undefined,
-            nullVal: null,
-        };
-        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(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)", () => {
-        const mock1 = createMockSocket();
-        const mock2 = createMockSocket();
-        const streamedSocket1 = new streamed_socket_1.StreamedSocket(mock1.socket, 1000000); // Large chunk to avoid splitting
-        const streamedSocket2 = new streamed_socket_1.StreamedSocket(mock2.socket, 1000000);
-        // Create a small structured object that won't trigger compression (< 1024 bytes)
-        const smallObject = {
-            users: Array.from({ length: 5 }, (_, i) => ({
-                id: i + 1000000, // Use larger numbers to make JSON less compressible
-                name: `User${i}_${Math.random().toString(36).substring(7)}`, // Add randomness
-                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, () => { });
-        // Send as JSON string (msgpack treats it as opaque string)
-        streamedSocket2.emit("test-string", { jsonPayload: jsonString }, () => { });
-        const objectEvents = mock1.getEmittedEvents();
-        const stringEvents = mock2.getEmittedEvents();
-        expect(objectEvents).toHaveLength(1);
-        expect(stringEvents).toHaveLength(1);
-        // Decode and measure sizes
-        const objectChunk = decodeChunk(objectEvents[0].args);
-        const stringChunk = decodeChunk(stringEvents[0].args);
-        const objectSize = objectChunk.data.length;
-        const stringSize = stringChunk.data.length;
-        console.log(`Msgpack with structured data: ${objectSize} bytes (${((1 - objectSize / jsonString.length) * 100).toFixed(1)}% reduction from JSON)`);
-        console.log(`Msgpack with JSON string: ${stringSize} bytes (${((1 - stringSize / jsonString.length) * 100).toFixed(1)}% reduction from JSON)`);
-        console.log(`Efficiency gain: structured data is ${((1 - objectSize / stringSize) * 100).toFixed(1)}% smaller than JSON string`);
-        // Msgpack should be more efficient with structured data than with a JSON string
-        expect(objectSize).toBeLessThan(stringSize);
-        // Structured data should be at least 10% more efficient
-        const efficiency = (1 - objectSize / stringSize) * 100;
-        expect(efficiency).toBeGreaterThan(10);
-        // Verify data integrity
-        const decodedObject = (0, tx_encoding_1.txDecode)(objectChunk.data);
-        const decodedString = (0, tx_encoding_1.txDecode)(stringChunk.data);
-        expect(decodedObject.users).toHaveLength(5);
-        expect(decodedString.jsonPayload).toBe(jsonString);
-    });
-    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" },
-            })),
-        };
-        const jsonString = JSON.stringify(largeObject);
-        console.log(`Large repetitive data - JSON size: ${jsonString.length} bytes`);
-        streamedSocket.emit("test-compressed", largeObject, () => { });
-        const events = mock.getEmittedEvents();
-        const chunk = decodeChunk(events[0].args);
-        console.log(`After msgpack + compression: ${chunk.data.length} bytes`);
-        console.log(`Compression ratio: ${((1 - chunk.data.length / jsonString.length) * 100).toFixed(1)}% reduction`);
-        // Should achieve significant compression (>80% reduction)
-        expect(chunk.data.length).toBeLessThan(jsonString.length * 0.2);
-        // Verify data integrity
-        const decoded = (0, tx_encoding_1.txDecode)(chunk.data);
-        expect(decoded.data).toHaveLength(200);
-        expect(decoded.data[0].type).toBe("event");
-    });
-});

package/dist/device/tx-encoding.test.d.ts

@@ -1 +0,0 @@
-export {};