peer-client 1.0.0

package/dist/react/usePeer.js

@@ -0,0 +1,49 @@
+import { useEffect, useState, useCallback } from 'react';
+import { usePeerContext } from './PeerProvider';
+export function usePeer(fingerprint) {
+    const { client } = usePeerContext();
+    const [peer, setPeer] = useState(null);
+    const [connectionState, setConnectionState] = useState('new');
+    useEffect(() => {
+        if (!client || !fingerprint)
+            return;
+        const existing = client.getPeer(fingerprint);
+        if (existing) {
+            setPeer(existing);
+            setConnectionState(existing.connectionState);
+        }
+        const offJoined = client.on('peer_joined', (info) => {
+            if (info.fingerprint === fingerprint) {
+                const p = client.getPeer(fingerprint);
+                if (p) {
+                    setPeer(p);
+                    setConnectionState(p.connectionState);
+                }
+            }
+        });
+        const offLeft = client.on('peer_left', (fp) => {
+            if (fp === fingerprint) {
+                setPeer(null);
+                setConnectionState('closed');
+            }
+        });
+        return () => {
+            offJoined();
+            offLeft();
+        };
+    }, [client, fingerprint]);
+    useEffect(() => {
+        if (!peer)
+            return;
+        const offConnected = peer.on('connected', () => setConnectionState('connected'));
+        const offDisconnected = peer.on('disconnected', (s) => setConnectionState(s));
+        return () => {
+            offConnected();
+            offDisconnected();
+        };
+    }, [peer]);
+    const send = useCallback((data, channel) => {
+        peer?.send(data, channel);
+    }, [peer]);
+    return { peer, connectionState, send };
+}

package/dist/react/usePeerClient.d.ts

@@ -0,0 +1,7 @@
+export declare function usePeerClient(): {
+    client: import("..").PeerClient | null;
+    connected: boolean;
+    fingerprint: string;
+    alias: string;
+    error: Error | null;
+};

package/dist/react/usePeerClient.js

@@ -0,0 +1,5 @@
+import { usePeerContext } from './PeerProvider';
+export function usePeerClient() {
+    const { client, connected, fingerprint, alias, error } = usePeerContext();
+    return { client, connected, fingerprint, alias, error };
+}

package/dist/react/useRelay.d.ts

@@ -0,0 +1,11 @@
+interface RelayMessage {
+    from: string;
+    payload: any;
+    ts: number;
+}
+export declare function useRelay(): {
+    messages: RelayMessage[];
+    send: (to: string, payload: any) => void;
+    clear: () => void;
+};
+export {};

package/dist/react/useRelay.js

@@ -0,0 +1,19 @@
+import { useEffect, useState, useCallback } from 'react';
+import { usePeerContext } from './PeerProvider';
+export function useRelay() {
+    const { client } = usePeerContext();
+    const [messages, setMessages] = useState([]);
+    useEffect(() => {
+        if (!client)
+            return;
+        const off = client.on('relay', (from, payload) => {
+            setMessages((prev) => [...prev, { from, payload, ts: Date.now() }]);
+        });
+        return () => { off(); };
+    }, [client]);
+    const send = useCallback((to, payload) => {
+        client?.relay(to, payload);
+    }, [client]);
+    const clear = useCallback(() => setMessages([]), []);
+    return { messages, send, clear };
+}

package/dist/react/useRoom.d.ts

@@ -0,0 +1,17 @@
+import { DirectRoom, GroupRoom } from '../room';
+import type { PeerInfo } from '../core/types';
+interface RoomMessage {
+    data: any;
+    from: string;
+    ts: number;
+}
+export declare function useRoom(roomId: string, type?: 'direct' | 'group', create?: boolean, maxSize?: number): {
+    joined: boolean;
+    peers: PeerInfo[];
+    messages: RoomMessage[];
+    send: (data: any, to?: string) => void;
+    clearMessages: () => void;
+    error: Error | null;
+    room: DirectRoom | GroupRoom | null;
+};
+export {};

package/dist/react/useRoom.js

@@ -0,0 +1,67 @@
+import { useEffect, useState, useCallback, useRef } from 'react';
+import { usePeerContext } from './PeerProvider';
+import { DirectRoom, GroupRoom } from '../room';
+export function useRoom(roomId, type = 'direct', create = false, maxSize = 20) {
+    const { client } = usePeerContext();
+    const [peers, setPeers] = useState([]);
+    const [messages, setMessages] = useState([]);
+    const [joined, setJoined] = useState(false);
+    const [error, setError] = useState(null);
+    const roomRef = useRef(null);
+    useEffect(() => {
+        if (!client || !roomId)
+            return;
+        const room = type === 'group'
+            ? new GroupRoom(client, roomId, maxSize)
+            : new DirectRoom(client, roomId);
+        roomRef.current = room;
+        room.on('peer_joined', (info) => {
+            setPeers((prev) => [...prev.filter((p) => p.fingerprint !== info.fingerprint), info]);
+        });
+        room.on('peer_left', (fp) => {
+            setPeers((prev) => prev.filter((p) => p.fingerprint !== fp));
+        });
+        room.on('data', (data, from) => {
+            setMessages((prev) => [...prev, { data, from, ts: Date.now() }]);
+        });
+        room.on('error', (e) => {
+            setError(e instanceof Error ? e : new Error(String(e)));
+        });
+        const init = async () => {
+            try {
+                if (create) {
+                    await room.create();
+                }
+                else {
+                    const peerList = await room.join();
+                    const others = peerList.filter((p) => p.fingerprint !== client.fingerprint);
+                    setPeers(others);
+                }
+                setJoined(true);
+            }
+            catch (e) {
+                setError(e instanceof Error ? e : new Error(String(e)));
+            }
+        };
+        init();
+        return () => {
+            room.close();
+            roomRef.current = null;
+            setJoined(false);
+            setPeers([]);
+        };
+    }, [client, roomId, type, maxSize, create]);
+    const send = useCallback((data, to) => {
+        const room = roomRef.current;
+        if (!room)
+            return;
+        if (room instanceof GroupRoom) {
+            room.send(data, to);
+        }
+        else {
+            room.send(data);
+        }
+    }, []);
+    const clearMessages = useCallback(() => setMessages([]), []);
+    return { joined, peers, messages, send, clearMessages, error, room: roomRef.current };
+}

package/dist/react/useSync.d.ts

@@ -0,0 +1,8 @@
+import type { SyncMode } from '../core/types';
+export declare function useSync(roomId: string, mode?: SyncMode, merge?: (local: any, remote: any) => any): {
+    state: Record<string, any>;
+    set: (key: string, value: any) => void;
+    delete: (key: string) => void;
+    get: (key: string) => any;
+    error: Error | null;
+};

package/dist/react/useSync.js

@@ -0,0 +1,45 @@
+import { useEffect, useState, useCallback, useRef } from 'react';
+import { usePeerContext } from './PeerProvider';
+import { StateSync } from '../sync';
+export function useSync(roomId, mode = 'lww', merge) {
+    const { client } = usePeerContext();
+    const [state, setState] = useState({});
+    const [error, setError] = useState(null);
+    const syncRef = useRef(null);
+    const mergeRef = useRef(merge);
+    mergeRef.current = merge;
+    useEffect(() => {
+        if (!client || !roomId)
+            return;
+        const sync = new StateSync(client, roomId, { mode, merge: mergeRef.current });
+        syncRef.current = sync;
+        sync.start();
+        sync.on('state_changed', () => {
+            setState(sync.getAll());
+        });
+        sync.on('error', (e) => {
+            setError(e instanceof Error ? e : new Error(String(e)));
+        });
+        return () => {
+            sync.destroy();
+            syncRef.current = null;
+            setState({});
+        };
+    }, [client, roomId, mode]);
+    const set = useCallback((key, value) => {
+        syncRef.current?.set(key, value);
+        setState((prev) => ({ ...prev, [key]: value }));
+    }, []);
+    const del = useCallback((key) => {
+        syncRef.current?.delete(key);
+        setState((prev) => {
+            const next = { ...prev };
+            delete next[key];
+            return next;
+        });
+    }, []);
+    const get = useCallback((key) => {
+        return syncRef.current?.get(key);
+    }, []);
+    return { state, set, delete: del, get, error };
+}

package/dist/room.d.ts

@@ -0,0 +1,44 @@
+import { Emitter } from './core/emitter';
+import type { PeerClient } from './core/client';
+import type { Peer } from './core/peer';
+import type { PeerInfo } from './core/types';
+type RoomEvent = 'peer_joined' | 'peer_left' | 'peer_connected' | 'data' | 'closed' | 'error';
+export declare class DirectRoom extends Emitter<RoomEvent> {
+    private client;
+    private roomId;
+    private remotePeer;
+    private remoteFingerprint;
+    private _closed;
+    private cleanups;
+    constructor(client: PeerClient, roomId: string);
+    create(): Promise<void>;
+    join(): Promise<PeerInfo[]>;
+    private listen;
+    private connectTo;
+    send(data: any): void;
+    getPeer(): Peer | null;
+    getRemoteFingerprint(): string;
+    close(): void;
+}
+export declare class GroupRoom extends Emitter<RoomEvent> {
+    private client;
+    private roomId;
+    private maxSize;
+    private connectedPeers;
+    private relayPeers;
+    private _closed;
+    private cleanups;
+    constructor(client: PeerClient, roomId: string, maxSize?: number);
+    create(): Promise<void>;
+    join(): Promise<PeerInfo[]>;
+    private listen;
+    private connectTo;
+    private promoteRelayPeers;
+    send(data: any, to?: string): void;
+    broadcastViaServer(data: any): void;
+    kick(fingerprint: string): void;
+    getPeers(): Map<string, Peer>;
+    getPeerCount(): number;
+    close(): void;
+}
+export {};

package/dist/room.js

@@ -0,0 +1,246 @@
+import { Emitter } from './core/emitter';
+import { LIMITS } from './core/types';
+export class DirectRoom extends Emitter {
+    client;
+    roomId;
+    remotePeer = null;
+    remoteFingerprint = '';
+    _closed = false;
+    cleanups = [];
+    constructor(client, roomId) {
+        super();
+        this.client = client;
+        this.roomId = roomId;
+    }
+    async create() {
+        await this.client.createRoom(this.roomId, { maxSize: 2 });
+        this.listen();
+    }
+    async join() {
+        const peers = await this.client.joinRoom(this.roomId);
+        this.listen();
+        const remote = peers.find((p) => p.fingerprint !== this.client.fingerprint);
+        if (remote) {
+            this.connectTo(remote.fingerprint, remote.alias);
+        }
+        return peers;
+    }
+    listen() {
+        const offJoined = this.client.on('peer_joined', (info) => {
+            this.emit('peer_joined', info);
+            if (!this.remotePeer) {
+                this.connectTo(info.fingerprint, info.alias);
+            }
+        });
+        const offLeft = this.client.on('peer_left', (fp) => {
+            if (fp === this.remoteFingerprint) {
+                this.remotePeer = null;
+                this.remoteFingerprint = '';
+                this.emit('peer_left', fp);
+            }
+        });
+        const offRelay = this.client.on('relay', (from, payload) => {
+            if (from === this.remoteFingerprint && payload?._room === this.roomId) {
+                this.emit('data', payload.data, from);
+            }
+        });
+        const offKicked = this.client.on('kicked', (payload) => {
+            if (payload?.room_id === this.roomId) {
+                this.close();
+            }
+        });
+        this.cleanups.push(offJoined, offLeft, offRelay, offKicked);
+    }
+    connectTo(fingerprint, alias) {
+        this.remoteFingerprint = fingerprint;
+        const peer = this.client.connectToPeer(fingerprint, alias);
+        this.remotePeer = peer;
+        peer.on('connected', () => this.emit('peer_connected', fingerprint));
+        peer.on('data', (data) => this.emit('data', data, fingerprint));
+        peer.on('disconnected', () => {
+            this.emit('peer_left', fingerprint);
+        });
+    }
+    send(data) {
+        if (this._closed)
+            return;
+        if (this.remotePeer && this.remotePeer.connectionState === 'connected') {
+            try {
+                this.remotePeer.send(data);
+                return;
+            }
+            catch { }
+        }
+        if (this.remoteFingerprint) {
+            this.client.relay(this.remoteFingerprint, { _room: this.roomId, data });
+        }
+    }
+    getPeer() {
+        return this.remotePeer;
+    }
+    getRemoteFingerprint() {
+        return this.remoteFingerprint;
+    }
+    close() {
+        if (this._closed)
+            return;
+        this._closed = true;
+        this.cleanups.forEach((fn) => fn());
+        this.cleanups = [];
+        if (this.remotePeer) {
+            this.remotePeer.close();
+        }
+        this.client.leave(this.roomId);
+        this.emit('closed');
+        this.removeAllListeners();
+    }
+}
+export class GroupRoom extends Emitter {
+    client;
+    roomId;
+    maxSize;
+    connectedPeers = new Map();
+    relayPeers = new Set();
+    _closed = false;
+    cleanups = [];
+    constructor(client, roomId, maxSize = LIMITS.MAX_GROUP_SIZE) {
+        super();
+        this.client = client;
+        this.roomId = roomId;
+        this.maxSize = Math.min(maxSize, LIMITS.MAX_GROUP_SIZE);
+    }
+    async create() {
+        await this.client.createRoom(this.roomId, { maxSize: this.maxSize });
+        this.listen();
+    }
+    async join() {
+        const peers = await this.client.joinRoom(this.roomId);
+        this.listen();
+        const others = peers.filter((p) => p.fingerprint !== this.client.fingerprint);
+        for (const p of others) {
+            this.connectTo(p.fingerprint, p.alias);
+        }
+        return peers;
+    }
+    listen() {
+        const offJoined = this.client.on('peer_joined', (info) => {
+            this.emit('peer_joined', info);
+            this.connectTo(info.fingerprint, info.alias);
+        });
+        const offLeft = this.client.on('peer_left', (fp) => {
+            const hadP2P = this.connectedPeers.has(fp);
+            this.connectedPeers.delete(fp);
+            this.relayPeers.delete(fp);
+            if (hadP2P) {
+                this.promoteRelayPeers();
+            }
+            this.emit('peer_left', fp);
+        });
+        const offRelay = this.client.on('relay', (from, payload) => {
+            if (payload?._room === this.roomId) {
+                this.emit('data', payload.data, from);
+            }
+        });
+        const offBroadcast = this.client.on('broadcast', (from, ns, payload) => {
+            if (ns === this.roomId) {
+                this.emit('data', payload, from);
+            }
+        });
+        const offKicked = this.client.on('kicked', (payload) => {
+            if (payload?.room_id === this.roomId) {
+                this.close();
+            }
+        });
+        this.cleanups.push(offJoined, offLeft, offRelay, offBroadcast, offKicked);
+    }
+    connectTo(fingerprint, alias) {
+        if (this.connectedPeers.has(fingerprint) || this.relayPeers.has(fingerprint))
+            return;
+        if (this.connectedPeers.size >= LIMITS.RELAY_THRESHOLD) {
+            this.relayPeers.add(fingerprint);
+            return;
+        }
+        const peer = this.client.connectToPeer(fingerprint, alias);
+        this.connectedPeers.set(fingerprint, peer);
+        peer.on('connected', () => this.emit('peer_connected', fingerprint));
+        peer.on('data', (data) => this.emit('data', data, fingerprint));
+        peer.on('disconnected', () => {
+            this.connectedPeers.delete(fingerprint);
+            this.relayPeers.add(fingerprint);
+        });
+    }
+    promoteRelayPeers() {
+        if (this.connectedPeers.size >= LIMITS.RELAY_THRESHOLD)
+            return;
+        const available = LIMITS.RELAY_THRESHOLD - this.connectedPeers.size;
+        const toPromote = [...this.relayPeers].slice(0, available);
+        for (const fp of toPromote) {
+            this.relayPeers.delete(fp);
+            const peer = this.client.connectToPeer(fp);
+            this.connectedPeers.set(fp, peer);
+            peer.on('connected', () => this.emit('peer_connected', fp));
+            peer.on('data', (data) => this.emit('data', data, fp));
+            peer.on('disconnected', () => {
+                this.connectedPeers.delete(fp);
+                this.relayPeers.add(fp);
+            });
+        }
+    }
+    send(data, to) {
+        if (this._closed)
+            return;
+        if (to) {
+            const peer = this.connectedPeers.get(to);
+            if (peer && peer.connectionState === 'connected') {
+                try {
+                    peer.send(data);
+                    return;
+                }
+                catch { }
+            }
+            this.client.relay(to, { _room: this.roomId, data });
+            return;
+        }
+        this.connectedPeers.forEach((peer, fp) => {
+            if (peer.connectionState === 'connected') {
+                try {
+                    peer.send(data);
+                }
+                catch {
+                    this.client.relay(fp, { _room: this.roomId, data });
+                }
+            }
+            else {
+                this.client.relay(fp, { _room: this.roomId, data });
+            }
+        });
+        this.relayPeers.forEach((fp) => {
+            this.client.relay(fp, { _room: this.roomId, data });
+        });
+    }
+    broadcastViaServer(data) {
+        this.client.broadcast(this.roomId, data);
+    }
+    kick(fingerprint) {
+        this.client.kick(this.roomId, fingerprint);
+    }
+    getPeers() {
+        return new Map(this.connectedPeers);
+    }
+    getPeerCount() {
+        return this.connectedPeers.size + this.relayPeers.size;
+    }
+    close() {
+        if (this._closed)
+            return;
+        this._closed = true;
+        this.cleanups.forEach((fn) => fn());
+        this.cleanups = [];
+        this.connectedPeers.forEach((p) => p.close());
+        this.connectedPeers.clear();
+        this.relayPeers.clear();
+        this.client.leave(this.roomId);
+        this.emit('closed');
+        this.removeAllListeners();
+    }
+}

package/dist/sync.d.ts

@@ -0,0 +1,45 @@
+import { Emitter } from './core/emitter';
+import type { PeerClient } from './core/client';
+import type { SyncConfig } from './core/types';
+type SyncEvent = 'state_changed' | 'conflict' | 'synced' | 'error';
+export declare class StateSync extends Emitter<SyncEvent> {
+    private client;
+    private state;
+    private mode;
+    private merge?;
+    private hlc;
+    private roomId;
+    private cleanups;
+    private tombstoneTimer;
+    constructor(client: PeerClient, roomId: string, config: SyncConfig);
+    start(): void;
+    private tick;
+    set(key: string, value: any): void;
+    get(key: string): any;
+    getAll(): Record<string, any>;
+    delete(key: string): void;
+    private handleRemoteUpdate;
+    private handleFullState;
+    private broadcastFullState;
+    private sendStateTo;
+    requestFullState(fingerprint: string): void;
+    private purgeTombstones;
+    destroy(): void;
+}
+export declare class CRDTSync extends Emitter<SyncEvent> {
+    private client;
+    private roomId;
+    private doc;
+    private cleanups;
+    private Yjs;
+    constructor(client: PeerClient, roomId: string, yjsModule: any);
+    getDoc(): any;
+    getMap(name?: string): any;
+    getText(name?: string): any;
+    getArray(name?: string): any;
+    start(): void;
+    private sendStateTo;
+    requestFullState(fingerprint: string): void;
+    destroy(): void;
+}
+export {};