peer-client 1.0.0

package/dist/transfer.js

@@ -0,0 +1,454 @@
+import { Emitter } from './core/emitter';
+import { LIMITS } from './core/types';
+function uid() {
+    return Math.random().toString(36).slice(2, 10) + Date.now().toString(36);
+}
+function encodeChunk(index, data) {
+    const header = new ArrayBuffer(4);
+    new DataView(header).setUint32(0, index, true);
+    const combined = new Uint8Array(4 + data.byteLength);
+    combined.set(new Uint8Array(header), 0);
+    combined.set(new Uint8Array(data), 4);
+    return combined.buffer;
+}
+function decodeChunk(buffer) {
+    const view = new DataView(buffer);
+    const index = view.getUint32(0, true);
+    const data = buffer.slice(4);
+    return { index, data };
+}
+export class FileTransfer extends Emitter {
+    client;
+    sending = new Map();
+    receiving = new Map();
+    channelListeners = new Map();
+    constructor(client) {
+        super();
+        this.client = client;
+    }
+    async send(peer, file, filename) {
+        if (peer.connectionState !== 'connected') {
+            throw new Error('Peer not connected — P2P required for file transfer');
+        }
+        const id = uid();
+        const name = filename ?? (file instanceof File ? file.name : 'file');
+        const chunkSize = LIMITS.CHUNK_SIZE;
+        const totalChunks = Math.ceil(file.size / chunkSize);
+        const channelLabel = `${LIMITS.TRANSFER_CHANNEL_PREFIX}${id}`;
+        const channel = peer.createDataChannel({
+            label: channelLabel,
+            ordered: true,
+        });
+        const offer = {
+            _ft: true,
+            type: 'offer',
+            id,
+            filename: name,
+            size: file.size,
+            mime: file.type || 'application/octet-stream',
+            chunkSize,
+            totalChunks,
+        };
+        peer.send(offer, 'data');
+        return new Promise((resolve, reject) => {
+            const active = {
+                id,
+                file,
+                filename: name,
+                peer,
+                channel,
+                totalChunks,
+                chunkSize,
+                currentIndex: 0,
+                cancelled: false,
+                paused: false,
+                startTime: Date.now(),
+                bytesSent: 0,
+                resolve,
+                reject,
+            };
+            this.sending.set(id, active);
+            const offData = peer.on('data', (data) => {
+                if (!data?._ft || data.id !== id)
+                    return;
+                if (data.type === 'accept') {
+                    this.startSending(active);
+                }
+                else if (data.type === 'cancel') {
+                    this.cancelSend(id);
+                }
+                else if (data.type === 'ack') {
+                    this.handleAck(id, data.index);
+                }
+                else if (data.type === 'resume') {
+                    active.currentIndex = data.lastIndex + 1;
+                    this.startSending(active);
+                }
+            });
+            this.channelListeners.set(id, offData);
+            const timeout = setTimeout(() => {
+                if (this.sending.has(id) && active.currentIndex === 0 && !active.cancelled) {
+                    this.cleanupSend(id);
+                    reject(new Error('Transfer offer timeout — peer did not accept'));
+                }
+            }, 30000);
+            const origResolve = active.resolve;
+            active.resolve = (rid) => {
+                clearTimeout(timeout);
+                origResolve(rid);
+            };
+            const origReject = active.reject;
+            active.reject = (e) => {
+                clearTimeout(timeout);
+                origReject(e);
+            };
+        });
+    }
+    accept(id) {
+        const recv = this.receiving.get(id);
+        if (!recv)
+            return;
+        const peer = this.client.getPeer(recv.from);
+        if (!peer)
+            return;
+        const control = { _ft: true, type: 'accept', id };
+        peer.send(control, 'data');
+    }
+    reject(id) {
+        const recv = this.receiving.get(id);
+        if (!recv)
+            return;
+        const peer = this.client.getPeer(recv.from);
+        if (peer) {
+            const control = { _ft: true, type: 'cancel', id };
+            peer.send(control, 'data');
+        }
+        this.receiving.delete(id);
+    }
+    cancel(id) {
+        if (this.sending.has(id)) {
+            this.cancelSend(id);
+        }
+        if (this.receiving.has(id)) {
+            const recv = this.receiving.get(id);
+            const peer = this.client.getPeer(recv.from);
+            if (peer) {
+                const control = { _ft: true, type: 'cancel', id };
+                try {
+                    peer.send(control, 'data');
+                }
+                catch { }
+            }
+            this.receiving.delete(id);
+            this.emit('cancelled', id);
+        }
+    }
+    handleIncoming(peer) {
+        const offData = peer.on('data', (data, channel) => {
+            if (data instanceof ArrayBuffer) {
+                this.handleBinaryChunk(data, peer.fingerprint, channel);
+                return;
+            }
+            if (data?._ft) {
+                this.handleControl(data, peer.fingerprint);
+            }
+        });
+        return offData;
+    }
+    requestResume(id, lastIndex) {
+        const recv = this.receiving.get(id);
+        if (!recv)
+            return;
+        const peer = this.client.getPeer(recv.from);
+        if (peer) {
+            const control = { _ft: true, type: 'resume', id, lastIndex };
+            peer.send(control, 'data');
+        }
+    }
+    getReceiveProgress(id) {
+        const recv = this.receiving.get(id);
+        if (!recv)
+            return null;
+        return {
+            id,
+            sent: recv.received,
+            total: recv.meta.totalChunks,
+            percentage: Math.round((recv.received / recv.meta.totalChunks) * 100),
+        };
+    }
+    handleControl(data, from) {
+        if (data.type === 'offer') {
+            const meta = {
+                id: data.id,
+                filename: data.filename,
+                size: data.size,
+                mime: data.mime,
+                totalChunks: data.totalChunks,
+                chunkSize: data.chunkSize,
+            };
+            const recv = {
+                id: data.id,
+                meta,
+                chunks: new Array(data.totalChunks).fill(null),
+                received: 0,
+                from,
+                startTime: Date.now(),
+            };
+            this.receiving.set(data.id, recv);
+            this.emit('incoming', meta, from);
+        }
+        else if (data.type === 'complete') {
+            this.assembleFile(data.id);
+        }
+        else if (data.type === 'cancel') {
+            if (this.sending.has(data.id)) {
+                this.cancelSend(data.id);
+            }
+            if (this.receiving.has(data.id)) {
+                this.receiving.delete(data.id);
+                this.emit('cancelled', data.id);
+            }
+        }
+    }
+    handleBinaryChunk(buffer, from, channel) {
+        if (!channel.startsWith(LIMITS.TRANSFER_CHANNEL_PREFIX))
+            return;
+        const transferId = channel.slice(LIMITS.TRANSFER_CHANNEL_PREFIX.length);
+        const recv = this.receiving.get(transferId);
+        if (!recv || recv.from !== from)
+            return;
+        const { index, data } = decodeChunk(buffer);
+        if (index >= recv.meta.totalChunks)
+            return;
+        if (recv.chunks[index] === null) {
+            recv.chunks[index] = data;
+            recv.received++;
+        }
+        const elapsed = (Date.now() - recv.startTime) / 1000 || 1;
+        const bytesReceived = recv.received * recv.meta.chunkSize;
+        const progress = {
+            id: transferId,
+            sent: recv.received,
+            total: recv.meta.totalChunks,
+            percentage: Math.round((recv.received / recv.meta.totalChunks) * 100),
+            bytesPerSecond: Math.round(bytesReceived / elapsed),
+        };
+        this.emit('progress', progress);
+        if (recv.received % LIMITS.ACK_INTERVAL === 0) {
+            const peer = this.client.getPeer(from);
+            if (peer) {
+                const ack = { _ft: true, type: 'ack', id: transferId, index };
+                try {
+                    peer.send(ack, 'data');
+                }
+                catch { }
+            }
+        }
+    }
+    async startSending(active) {
+        const { channel } = active;
+        if (channel.readyState !== 'open') {
+            await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => reject(new Error('Transfer channel open timeout')), 15000);
+                channel.onopen = () => {
+                    clearTimeout(timeout);
+                    resolve();
+                };
+            });
+        }
+        channel.binaryType = 'arraybuffer';
+        channel.bufferedAmountLowThreshold = LIMITS.BUFFERED_AMOUNT_LOW;
+        const sendNext = async () => {
+            while (active.currentIndex < active.totalChunks && !active.cancelled) {
+                if (channel.bufferedAmount > LIMITS.BUFFERED_AMOUNT_HIGH) {
+                    await new Promise((resolve) => {
+                        channel.onbufferedamountlow = () => {
+                            channel.onbufferedamountlow = null;
+                            resolve();
+                        };
+                    });
+                    if (active.cancelled)
+                        break;
+                }
+                const start = active.currentIndex * active.chunkSize;
+                const end = Math.min(start + active.chunkSize, active.file.size);
+                const slice = active.file.slice(start, end);
+                const buffer = await new Response(slice).arrayBuffer();
+                const encoded = encodeChunk(active.currentIndex, buffer);
+                try {
+                    channel.send(encoded);
+                }
+                catch (e) {
+                    this.cleanupSend(active.id);
+                    active.reject(new Error(`Send failed at chunk ${active.currentIndex}: ${e}`));
+                    return;
+                }
+                active.bytesSent += buffer.byteLength;
+                active.currentIndex++;
+                const elapsed = (Date.now() - active.startTime) / 1000 || 1;
+                const progress = {
+                    id: active.id,
+                    sent: active.currentIndex,
+                    total: active.totalChunks,
+                    percentage: Math.round((active.currentIndex / active.totalChunks) * 100),
+                    bytesPerSecond: Math.round(active.bytesSent / elapsed),
+                };
+                this.emit('progress', progress);
+                if (active.currentIndex % 50 === 0) {
+                    await new Promise((r) => setTimeout(r, 0));
+                }
+            }
+            if (!active.cancelled && active.currentIndex >= active.totalChunks) {
+                // Ensure the buffer is empty before closing the channel and sending completion.
+                // This prevents race conditions where 'complete' message arrives before the last chunk.
+                try {
+                    while (channel.bufferedAmount > 0) {
+                        await new Promise((r) => setTimeout(r, 10));
+                    }
+                }
+                catch (e) { }
+                // Small safety delay to ensure underlying transport flush
+                await new Promise((r) => setTimeout(r, 10));
+                const complete = { _ft: true, type: 'complete', id: active.id };
+                try {
+                    active.peer.send(complete, 'data');
+                }
+                catch { }
+                this.emit('complete', active.id, 'sent');
+                this.cleanupSend(active.id);
+                active.resolve(active.id);
+            }
+        };
+        sendNext().catch((e) => {
+            this.cleanupSend(active.id);
+            active.reject(e);
+        });
+    }
+    handleAck(_id, _index) {
+    }
+    assembleFile(id) {
+        const recv = this.receiving.get(id);
+        if (!recv)
+            return;
+        const missing = recv.chunks.findIndex((c) => c === null);
+        if (missing !== -1 && missing < recv.meta.totalChunks) {
+            this.emit('error', { id, message: `Missing chunk ${missing}` });
+            return;
+        }
+        const parts = recv.chunks.filter((c) => c !== null);
+        const blob = new Blob(parts, { type: recv.meta.mime });
+        this.receiving.delete(id);
+        this.emit('complete', id, blob, recv.meta, recv.from);
+    }
+    cancelSend(id) {
+        const active = this.sending.get(id);
+        if (!active)
+            return;
+        active.cancelled = true;
+        this.cleanupSend(id);
+        this.emit('cancelled', id);
+        active.reject(new Error('Transfer cancelled'));
+    }
+    cleanupSend(id) {
+        const active = this.sending.get(id);
+        if (active) {
+            try {
+                active.channel.close();
+            }
+            catch { }
+        }
+        this.sending.delete(id);
+        const offData = this.channelListeners.get(id);
+        if (offData) {
+            offData();
+            this.channelListeners.delete(id);
+        }
+    }
+    destroy() {
+        this.sending.forEach((_, id) => {
+            const active = this.sending.get(id);
+            if (active)
+                active.cancelled = true;
+        });
+        this.sending.forEach((_, id) => this.cleanupSend(id));
+        this.receiving.clear();
+        this.removeAllListeners();
+    }
+}
+export class JSONTransfer {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    sendToPeer(fingerprint, data, channel = 'data') {
+        const peer = this.client.getPeer(fingerprint);
+        if (peer && peer.connectionState === 'connected') {
+            try {
+                peer.send({ _json_transfer: true, data }, channel);
+                return;
+            }
+            catch { }
+        }
+        this.client.relay(fingerprint, { _json_transfer: true, data });
+    }
+    sendToRoom(roomId, data) {
+        this.client.broadcast(roomId, { _json_transfer: true, data });
+    }
+    onReceive(peer, callback) {
+        return peer.on('data', (raw) => {
+            if (raw?._json_transfer) {
+                callback(raw.data, peer.fingerprint);
+            }
+        });
+    }
+    onRelayReceive(callback) {
+        return this.client.on('relay', (from, payload) => {
+            if (payload?._json_transfer) {
+                callback(payload.data, from);
+            }
+        });
+    }
+    onBroadcastReceive(roomId, callback) {
+        return this.client.on('broadcast', (from, ns, payload) => {
+            if (ns === roomId && payload?._json_transfer) {
+                callback(payload.data, from);
+            }
+        });
+    }
+}
+export class ImageTransfer extends Emitter {
+    ft;
+    client;
+    constructor(client) {
+        super();
+        this.client = client;
+        this.ft = new FileTransfer(client);
+        this.ft.on('progress', (...args) => this.emit('progress', ...args));
+        this.ft.on('incoming', (...args) => this.emit('incoming', ...args));
+        this.ft.on('cancelled', (...args) => this.emit('cancelled', ...args));
+        this.ft.on('complete', (...args) => this.emit('complete', ...args));
+        this.ft.on('error', (...args) => this.emit('error', ...args));
+    }
+    getFileTransfer() {
+        return this.ft;
+    }
+    async send(peer, image, filename) {
+        return this.ft.send(peer, image, filename);
+    }
+    accept(id) {
+        this.ft.accept(id);
+    }
+    reject(id) {
+        this.ft.reject(id);
+    }
+    cancel(id) {
+        this.ft.cancel(id);
+    }
+    handleIncoming(peer) {
+        return this.ft.handleIncoming(peer);
+    }
+    destroy() {
+        this.ft.destroy();
+        this.removeAllListeners();
+    }
+}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "peer-client",
+  "version": "1.0.0",
+  "description": "Universal WebRTC peer-to-peer library with signaling, rooms, file transfer, state sync, and E2E encryption",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./react": {
+      "import": "./dist/react/index.js",
+      "types": "./dist/react/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "webrtc",
+    "p2p",
+    "peer-to-peer",
+    "signaling",
+    "file-transfer",
+    "crdt",
+    "e2e-encryption",
+    "data-channel",
+    "rooms",
+    "state-sync"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@types/ws": "^8.18.1",
+    "@vitest/browser": "^4.0.18",
+    "jsdom": "^28.0.0",
+    "node-datachannel": "^0.32.1",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "typescript": "^5.7.3",
+    "vitest": "^4.0.18",
+    "ws": "^8.19.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
+    "test:react": "vitest run --config vitest.react.config.ts"
+  }
+}