peer-client 1.0.0

package/dist/sync.js

@@ -0,0 +1,333 @@
+import { Emitter } from './core/emitter';
+import { LIMITS } from './core/types';
+function createHLC(node, existing) {
+    const now = Date.now();
+    if (!existing)
+        return { ts: now, counter: 0, node };
+    const ts = Math.max(now, existing.ts);
+    const counter = ts === existing.ts ? existing.counter + 1 : 0;
+    return { ts, counter, node };
+}
+function mergeHLC(local, remote, node) {
+    const now = Date.now();
+    const maxTs = Math.max(now, local.ts, remote.ts);
+    let counter = 0;
+    if (maxTs === local.ts && maxTs === remote.ts) {
+        counter = Math.max(local.counter, remote.counter) + 1;
+    }
+    else if (maxTs === local.ts) {
+        counter = local.counter + 1;
+    }
+    else if (maxTs === remote.ts) {
+        counter = remote.counter + 1;
+    }
+    return { ts: maxTs, counter, node };
+}
+function compareHLC(a, b) {
+    if (a.ts !== b.ts)
+        return a.ts - b.ts;
+    if (a.counter !== b.counter)
+        return a.counter - b.counter;
+    return a.node < b.node ? -1 : a.node > b.node ? 1 : 0;
+}
+export class StateSync extends Emitter {
+    client;
+    state = new Map();
+    mode;
+    merge;
+    hlc;
+    roomId;
+    cleanups = [];
+    tombstoneTimer = null;
+    constructor(client, roomId, config) {
+        super();
+        this.client = client;
+        this.roomId = roomId;
+        this.mode = config.mode;
+        this.merge = config.merge;
+        this.hlc = { ts: Date.now(), counter: 0, node: client.fingerprint };
+        if (this.mode === 'operational' && !this.merge) {
+            throw new Error('Operational sync requires a merge function');
+        }
+    }
+    start() {
+        const offBroadcast = this.client.on('broadcast', (from, ns, payload) => {
+            if (ns === this.roomId && payload?._sync) {
+                this.handleRemoteUpdate(payload, from);
+            }
+        });
+        const offRelay = this.client.on('relay', (from, payload) => {
+            if (payload?._sync && payload?._room === this.roomId) {
+                this.handleRemoteUpdate(payload, from);
+            }
+        });
+        const offJoined = this.client.on('peer_joined', () => {
+            this.broadcastFullState();
+        });
+        this.tombstoneTimer = setInterval(() => this.purgeTombstones(), LIMITS.TOMBSTONE_TTL);
+        this.cleanups.push(offBroadcast, offRelay, offJoined);
+    }
+    tick() {
+        this.hlc = createHLC(this.client.fingerprint, this.hlc);
+        return this.hlc;
+    }
+    set(key, value) {
+        const hlc = this.tick();
+        const entry = {
+            key,
+            value,
+            hlc,
+            from: this.client.fingerprint,
+            version: hlc.counter,
+        };
+        this.state.set(key, entry);
+        this.emit('state_changed', key, value, this.client.fingerprint);
+        this.client.broadcast(this.roomId, {
+            _sync: true,
+            type: 'update',
+            entry,
+        });
+    }
+    get(key) {
+        const entry = this.state.get(key);
+        if (entry?.deleted)
+            return undefined;
+        return entry?.value;
+    }
+    getAll() {
+        const result = {};
+        this.state.forEach((entry, key) => {
+            if (!entry.deleted) {
+                result[key] = entry.value;
+            }
+        });
+        return result;
+    }
+    delete(key) {
+        const hlc = this.tick();
+        const entry = {
+            key,
+            value: undefined,
+            hlc,
+            from: this.client.fingerprint,
+            version: hlc.counter,
+            deleted: true,
+        };
+        this.state.set(key, entry);
+        this.client.broadcast(this.roomId, {
+            _sync: true,
+            type: 'delete',
+            entry,
+        });
+        this.emit('state_changed', key, undefined, this.client.fingerprint);
+    }
+    handleRemoteUpdate(payload, from) {
+        if (payload.type === 'full_state') {
+            this.handleFullState(payload.state, from);
+            return;
+        }
+        if (payload.type === 'request_state') {
+            this.sendStateTo(from);
+            return;
+        }
+        if (payload.type === 'delete') {
+            const remote = payload.entry;
+            if (!remote?.hlc)
+                return;
+            this.hlc = mergeHLC(this.hlc, remote.hlc, this.client.fingerprint);
+            const local = this.state.get(remote.key);
+            if (!local || compareHLC(remote.hlc, local.hlc) > 0) {
+                this.state.set(remote.key, remote);
+                this.emit('state_changed', remote.key, undefined, from);
+            }
+            this.emit('synced', from);
+            return;
+        }
+        if (payload.type !== 'update' || !payload.entry)
+            return;
+        const remote = payload.entry;
+        if (!remote?.hlc)
+            return;
+        this.hlc = mergeHLC(this.hlc, remote.hlc, this.client.fingerprint);
+        const local = this.state.get(remote.key);
+        switch (this.mode) {
+            case 'lww': {
+                if (!local || compareHLC(remote.hlc, local.hlc) > 0) {
+                    this.state.set(remote.key, remote);
+                    this.emit('state_changed', remote.key, remote.value, from);
+                }
+                break;
+            }
+            case 'operational': {
+                if (!local || local.deleted) {
+                    this.state.set(remote.key, remote);
+                    this.emit('state_changed', remote.key, remote.value, from);
+                }
+                else {
+                    const merged = this.merge(local.value, remote.value);
+                    const hlc = this.tick();
+                    const entry = {
+                        key: remote.key,
+                        value: merged,
+                        hlc,
+                        from: this.client.fingerprint,
+                        version: hlc.counter,
+                    };
+                    this.state.set(remote.key, entry);
+                    this.emit('state_changed', remote.key, merged, from);
+                    this.emit('conflict', remote.key, local.value, remote.value, merged);
+                }
+                break;
+            }
+            case 'crdt': {
+                this.emit('error', new Error('CRDT mode requires CRDTSync class'));
+                break;
+            }
+        }
+        this.emit('synced', from);
+    }
+    handleFullState(remoteState, from) {
+        for (const remote of remoteState) {
+            if (!remote?.hlc)
+                continue;
+            this.hlc = mergeHLC(this.hlc, remote.hlc, this.client.fingerprint);
+            const local = this.state.get(remote.key);
+            if (!local || compareHLC(remote.hlc, local.hlc) > 0) {
+                this.state.set(remote.key, remote);
+                if (!remote.deleted) {
+                    this.emit('state_changed', remote.key, remote.value, from);
+                }
+            }
+        }
+        this.emit('synced', from);
+    }
+    broadcastFullState() {
+        const entries = Array.from(this.state.values());
+        if (entries.length === 0)
+            return;
+        this.client.broadcast(this.roomId, {
+            _sync: true,
+            type: 'full_state',
+            state: entries,
+        });
+    }
+    sendStateTo(fingerprint) {
+        const entries = Array.from(this.state.values());
+        if (entries.length === 0)
+            return;
+        this.client.relay(fingerprint, {
+            _sync: true,
+            _room: this.roomId,
+            type: 'full_state',
+            state: entries,
+        });
+    }
+    requestFullState(fingerprint) {
+        this.client.relay(fingerprint, {
+            _sync: true,
+            _room: this.roomId,
+            type: 'request_state',
+        });
+    }
+    purgeTombstones() {
+        const now = Date.now();
+        for (const [key, entry] of this.state) {
+            if (entry.deleted && now - entry.hlc.ts > LIMITS.TOMBSTONE_TTL) {
+                this.state.delete(key);
+            }
+        }
+    }
+    destroy() {
+        this.cleanups.forEach((fn) => fn());
+        this.cleanups = [];
+        if (this.tombstoneTimer) {
+            clearInterval(this.tombstoneTimer);
+            this.tombstoneTimer = null;
+        }
+        this.state.clear();
+        this.removeAllListeners();
+    }
+}
+export class CRDTSync extends Emitter {
+    client;
+    roomId;
+    doc = null;
+    cleanups = [];
+    Yjs = null;
+    constructor(client, roomId, yjsModule) {
+        super();
+        this.client = client;
+        this.roomId = roomId;
+        this.Yjs = yjsModule;
+        this.doc = new yjsModule.Doc();
+    }
+    getDoc() {
+        return this.doc;
+    }
+    getMap(name = 'shared') {
+        return this.doc.getMap(name);
+    }
+    getText(name = 'text') {
+        return this.doc.getText(name);
+    }
+    getArray(name = 'array') {
+        return this.doc.getArray(name);
+    }
+    start() {
+        this.doc.on('update', (update, origin) => {
+            if (origin !== 'remote') {
+                const encoded = btoa(String.fromCharCode(...update));
+                this.client.broadcast(this.roomId, {
+                    _crdt_sync: true,
+                    update: encoded,
+                });
+            }
+        });
+        const offBroadcast = this.client.on('broadcast', (from, ns, payload) => {
+            if (ns === this.roomId && payload?._crdt_sync && payload.update) {
+                const bytes = Uint8Array.from(atob(payload.update), (c) => c.charCodeAt(0));
+                this.Yjs.applyUpdate(this.doc, bytes, 'remote');
+                this.emit('synced', from);
+            }
+        });
+        const offRelay = this.client.on('relay', (from, payload) => {
+            if (payload?._crdt_sync && payload._room === this.roomId) {
+                if (payload.update) {
+                    const bytes = Uint8Array.from(atob(payload.update), (c) => c.charCodeAt(0));
+                    this.Yjs.applyUpdate(this.doc, bytes, 'remote');
+                    this.emit('synced', from);
+                }
+                if (payload.type === 'request_state') {
+                    this.sendStateTo(from);
+                }
+            }
+        });
+        const offJoined = this.client.on('peer_joined', (info) => {
+            this.sendStateTo(info.fingerprint);
+        });
+        this.cleanups.push(offBroadcast, offRelay, offJoined);
+    }
+    sendStateTo(fingerprint) {
+        const state = this.Yjs.encodeStateAsUpdate(this.doc);
+        const encoded = btoa(String.fromCharCode(...state));
+        this.client.relay(fingerprint, {
+            _crdt_sync: true,
+            _room: this.roomId,
+            update: encoded,
+        });
+    }
+    requestFullState(fingerprint) {
+        this.client.relay(fingerprint, {
+            _crdt_sync: true,
+            _room: this.roomId,
+            type: 'request_state',
+        });
+    }
+    destroy() {
+        this.cleanups.forEach((fn) => fn());
+        this.cleanups = [];
+        this.doc?.destroy();
+        this.doc = null;
+        this.removeAllListeners();
+    }
+}

package/dist/transfer.d.ts

@@ -0,0 +1,49 @@
+import { Emitter } from './core/emitter';
+import type { PeerClient } from './core/client';
+import type { Peer } from './core/peer';
+import type { TransferProgress } from './core/types';
+type TransferEvent = 'incoming' | 'progress' | 'complete' | 'error' | 'cancelled';
+export declare class FileTransfer extends Emitter<TransferEvent> {
+    private client;
+    private sending;
+    private receiving;
+    private channelListeners;
+    constructor(client: PeerClient);
+    send(peer: Peer, file: File | Blob, filename?: string): Promise<string>;
+    accept(id: string): void;
+    reject(id: string): void;
+    cancel(id: string): void;
+    handleIncoming(peer: Peer): () => void;
+    requestResume(id: string, lastIndex: number): void;
+    getReceiveProgress(id: string): TransferProgress | null;
+    private handleControl;
+    private handleBinaryChunk;
+    private startSending;
+    private handleAck;
+    private assembleFile;
+    private cancelSend;
+    private cleanupSend;
+    destroy(): void;
+}
+export declare class JSONTransfer {
+    private client;
+    constructor(client: PeerClient);
+    sendToPeer(fingerprint: string, data: any, channel?: string): void;
+    sendToRoom(roomId: string, data: any): void;
+    onReceive(peer: Peer, callback: (data: any, from: string) => void): () => void;
+    onRelayReceive(callback: (data: any, from: string) => void): () => void;
+    onBroadcastReceive(roomId: string, callback: (data: any, from: string) => void): () => void;
+}
+export declare class ImageTransfer extends Emitter<TransferEvent> {
+    private ft;
+    private client;
+    constructor(client: PeerClient);
+    getFileTransfer(): FileTransfer;
+    send(peer: Peer, image: File | Blob, filename?: string): Promise<string>;
+    accept(id: string): void;
+    reject(id: string): void;
+    cancel(id: string): void;
+    handleIncoming(peer: Peer): () => void;
+    destroy(): void;
+}
+export {};