peer-client 1.0.0

package/dist/react/Video.d.ts

@@ -0,0 +1,7 @@
+import { type VideoHTMLAttributes } from 'react';
+interface VideoProps extends Omit<VideoHTMLAttributes<HTMLVideoElement>, 'ref'> {
+    stream: MediaStream | null;
+    muted?: boolean;
+}
+export declare function Video({ stream, muted, ...props }: VideoProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/react/Video.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useRef } from 'react';
+export function Video({ stream, muted = false, ...props }) {
+    const ref = useRef(null);
+    useEffect(() => {
+        if (!ref.current)
+            return;
+        ref.current.srcObject = stream;
+        if (stream) {
+            ref.current.play().catch(() => { });
+        }
+        return () => {
+            if (ref.current)
+                ref.current.srcObject = null;
+        };
+    }, [stream]);
+    return _jsx("video", { ref: ref, autoPlay: true, playsInline: true, muted: muted, ...props });
+}

package/dist/react/index.d.ts

@@ -0,0 +1,19 @@
+export { PeerProvider, usePeerContext } from './PeerProvider';
+export { usePeerClient } from './usePeerClient';
+export { usePeer } from './usePeer';
+export { useRoom } from './useRoom';
+export { useMedia } from './useMedia';
+export { useFileTransfer } from './useFileTransfer';
+export type { Transfer } from './useFileTransfer';
+export { useSync } from './useSync';
+export { useE2E } from './useE2E';
+export { useNamespace } from './useNamespace';
+export { useRelay } from './useRelay';
+export { useBroadcast } from './useBroadcast';
+export { useMatch } from './useMatch';
+export { useIdentity } from './useIdentity';
+export { useCRDT } from './useCRDT';
+export { Video } from './Video';
+export { Audio } from './Audio';
+export { TransferProgress } from './TransferProgress';
+export { PeerStatus } from './PeerStatus';

package/dist/react/index.js

@@ -0,0 +1,18 @@
+export { PeerProvider, usePeerContext } from './PeerProvider';
+export { usePeerClient } from './usePeerClient';
+export { usePeer } from './usePeer';
+export { useRoom } from './useRoom';
+export { useMedia } from './useMedia';
+export { useFileTransfer } from './useFileTransfer';
+export { useSync } from './useSync';
+export { useE2E } from './useE2E';
+export { useNamespace } from './useNamespace';
+export { useRelay } from './useRelay';
+export { useBroadcast } from './useBroadcast';
+export { useMatch } from './useMatch';
+export { useIdentity } from './useIdentity';
+export { useCRDT } from './useCRDT';
+export { Video } from './Video';
+export { Audio } from './Audio';
+export { TransferProgress } from './TransferProgress';
+export { PeerStatus } from './PeerStatus';

package/dist/react/useBroadcast.d.ts

@@ -0,0 +1,12 @@
+interface BroadcastMessage {
+    from: string;
+    namespace: string;
+    payload: any;
+    ts: number;
+}
+export declare function useBroadcast(namespace: string): {
+    messages: BroadcastMessage[];
+    send: (payload: any) => void;
+    clear: () => void;
+};
+export {};

package/dist/react/useBroadcast.js

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

package/dist/react/useCRDT.d.ts

@@ -0,0 +1,8 @@
+export declare function useCRDT(roomId: string, Y: any): {
+    ready: boolean;
+    getDoc: () => any;
+    getMap: (name: string) => any;
+    getText: (name: string) => any;
+    getArray: (name: string) => any;
+    error: Error | null;
+};

package/dist/react/useCRDT.js

@@ -0,0 +1,37 @@
+import { useEffect, useState, useCallback, useRef } from 'react';
+import { usePeerContext } from './PeerProvider';
+import { CRDTSync } from '../sync';
+export function useCRDT(roomId, Y) {
+    const { client } = usePeerContext();
+    const [ready, setReady] = useState(false);
+    const [error, setError] = useState(null);
+    const crdtRef = useRef(null);
+    const yRef = useRef(Y);
+    yRef.current = Y;
+    useEffect(() => {
+        if (!client || !roomId || !yRef.current)
+            return;
+        const crdt = new CRDTSync(client, roomId, yRef.current);
+        crdtRef.current = crdt;
+        crdt.start();
+        setReady(true);
+        return () => {
+            crdt.destroy();
+            crdtRef.current = null;
+            setReady(false);
+        };
+    }, [client, roomId]);
+    const getDoc = useCallback(() => {
+        return crdtRef.current?.getDoc() ?? null;
+    }, []);
+    const getMap = useCallback((name) => {
+        return crdtRef.current?.getMap(name) ?? null;
+    }, []);
+    const getText = useCallback((name) => {
+        return crdtRef.current?.getText(name) ?? null;
+    }, []);
+    const getArray = useCallback((name) => {
+        return crdtRef.current?.getArray(name) ?? null;
+    }, []);
+    return { ready, getDoc, getMap, getText, getArray, error };
+}

package/dist/react/useE2E.d.ts

@@ -0,0 +1,11 @@
+import type { Peer } from '../core/peer';
+export declare function useE2E(): {
+    ready: boolean;
+    exchangedPeers: Set<string>;
+    exchange: (peer: Peer) => Promise<void>;
+    handleIncoming: (peer: Peer, data: any) => Promise<void>;
+    encrypt: (fingerprint: string, data: any) => Promise<string>;
+    decrypt: (fingerprint: string, data: string) => Promise<any>;
+    hasKey: (fingerprint: string) => boolean;
+    error: Error | null;
+};

package/dist/react/useE2E.js

@@ -0,0 +1,62 @@
+import { useEffect, useState, useCallback, useRef } from 'react';
+import { usePeerContext } from './PeerProvider';
+import { GroupKeyManager } from '../crypto';
+export function useE2E() {
+    const { client } = usePeerContext();
+    const [ready, setReady] = useState(false);
+    const [exchangedPeers, setExchangedPeers] = useState(new Set());
+    const [error, setError] = useState(null);
+    const kmRef = useRef(null);
+    useEffect(() => {
+        if (!client)
+            return;
+        const km = new GroupKeyManager(client);
+        kmRef.current = km;
+        km.init()
+            .then(() => setReady(true))
+            .catch((e) => setError(e instanceof Error ? e : new Error(String(e))));
+        return () => {
+            km.destroy();
+            kmRef.current = null;
+            setReady(false);
+            setExchangedPeers(new Set());
+        };
+    }, [client]);
+    const exchange = useCallback(async (peer) => {
+        if (!kmRef.current)
+            throw new Error('E2E not initialized');
+        await kmRef.current.exchangeWith(peer);
+        setExchangedPeers((prev) => new Set(prev).add(peer.fingerprint));
+    }, []);
+    const handleIncoming = useCallback(async (peer, data) => {
+        if (!kmRef.current)
+            return;
+        await kmRef.current.handleIncomingKeyExchange(peer, data);
+        if (kmRef.current.getE2E().hasKey(peer.fingerprint)) {
+            setExchangedPeers((prev) => new Set(prev).add(peer.fingerprint));
+        }
+    }, []);
+    const encrypt = useCallback(async (fingerprint, data) => {
+        if (!kmRef.current)
+            throw new Error('E2E not initialized');
+        return kmRef.current.encryptForPeer(fingerprint, data);
+    }, []);
+    const decrypt = useCallback(async (fingerprint, data) => {
+        if (!kmRef.current)
+            throw new Error('E2E not initialized');
+        return kmRef.current.decryptFromPeer(fingerprint, data);
+    }, []);
+    const hasKey = useCallback((fingerprint) => {
+        return kmRef.current?.getE2E().hasKey(fingerprint) ?? false;
+    }, []);
+    return {
+        ready,
+        exchangedPeers,
+        exchange,
+        handleIncoming,
+        encrypt,
+        decrypt,
+        hasKey,
+        error,
+    };
+}

package/dist/react/useFileTransfer.d.ts

@@ -0,0 +1,24 @@
+import type { Peer } from '../core/peer';
+import type { FileMetadata } from '../core/types';
+interface Transfer {
+    id: string;
+    filename: string;
+    size: number;
+    direction: 'send' | 'receive';
+    from?: string;
+    progress: number;
+    bytesPerSecond: number;
+    status: 'pending' | 'active' | 'complete' | 'cancelled' | 'error';
+    blob?: Blob;
+    meta?: FileMetadata;
+}
+export type { Transfer };
+export declare function useFileTransfer(): {
+    transfers: Map<string, Transfer>;
+    send: (peer: Peer, file: File | Blob, filename?: string) => Promise<string>;
+    accept: (id: string) => void;
+    reject: (id: string) => void;
+    cancel: (id: string) => void;
+    listenToPeer: (peer: Peer) => () => void;
+    clearCompleted: () => void;
+};

package/dist/react/useFileTransfer.js

@@ -0,0 +1,133 @@
+import { useEffect, useState, useCallback, useRef } from 'react';
+import { usePeerContext } from './PeerProvider';
+import { FileTransfer } from '../transfer';
+export function useFileTransfer() {
+    const { client } = usePeerContext();
+    const [transfers, setTransfers] = useState(new Map());
+    const ftRef = useRef(null);
+    const cleanupRefs = useRef([]);
+    useEffect(() => {
+        if (!client)
+            return;
+        ftRef.current = new FileTransfer(client);
+        const ft = ftRef.current;
+        ft.on('progress', (p) => {
+            setTransfers((prev) => {
+                const next = new Map(prev);
+                const t = next.get(p.id);
+                if (t) {
+                    next.set(p.id, { ...t, progress: p.percentage, bytesPerSecond: p.bytesPerSecond ?? 0, status: 'active' });
+                }
+                return next;
+            });
+        });
+        ft.on('incoming', (meta, from) => {
+            setTransfers((prev) => {
+                const next = new Map(prev);
+                next.set(meta.id, {
+                    id: meta.id,
+                    filename: meta.filename,
+                    size: meta.size,
+                    direction: 'receive',
+                    from,
+                    progress: 0,
+                    bytesPerSecond: 0,
+                    status: 'pending',
+                    meta,
+                });
+                return next;
+            });
+        });
+        ft.on('complete', (id, blob) => {
+            setTransfers((prev) => {
+                const next = new Map(prev);
+                const t = next.get(id);
+                if (t) {
+                    next.set(id, { ...t, progress: 100, status: 'complete', blob: blob instanceof Blob ? blob : undefined });
+                }
+                return next;
+            });
+        });
+        ft.on('cancelled', (id) => {
+            setTransfers((prev) => {
+                const next = new Map(prev);
+                const t = next.get(id);
+                if (t)
+                    next.set(id, { ...t, status: 'cancelled' });
+                return next;
+            });
+        });
+        ft.on('error', (err) => {
+            const id = err?.id;
+            if (id) {
+                setTransfers((prev) => {
+                    const next = new Map(prev);
+                    const t = next.get(id);
+                    if (t)
+                        next.set(id, { ...t, status: 'error' });
+                    return next;
+                });
+            }
+        });
+        return () => {
+            cleanupRefs.current.forEach((fn) => fn());
+            cleanupRefs.current = [];
+            ft.destroy();
+            ftRef.current = null;
+        };
+    }, [client]);
+    const send = useCallback(async (peer, file, filename) => {
+        if (!ftRef.current)
+            throw new Error('FileTransfer not initialized');
+        const name = filename ?? (file instanceof File ? file.name : 'file');
+        const id = crypto.randomUUID();
+        setTransfers((prev) => {
+            const next = new Map(prev);
+            next.set(id, {
+                id,
+                filename: name,
+                size: file.size,
+                direction: 'send',
+                progress: 0,
+                bytesPerSecond: 0,
+                status: 'active',
+            });
+            return next;
+        });
+        await ftRef.current.send(peer, file, name);
+        return id;
+    }, []);
+    const accept = useCallback((id) => {
+        ftRef.current?.accept(id);
+    }, []);
+    const reject = useCallback((id) => {
+        ftRef.current?.reject(id);
+        setTransfers((prev) => {
+            const next = new Map(prev);
+            next.delete(id);
+            return next;
+        });
+    }, []);
+    const cancel = useCallback((id) => {
+        ftRef.current?.cancel(id);
+    }, []);
+    const listenToPeer = useCallback((peer) => {
+        if (!ftRef.current)
+            return () => { };
+        const off = ftRef.current.handleIncoming(peer);
+        cleanupRefs.current.push(off);
+        return off;
+    }, []);
+    const clearCompleted = useCallback(() => {
+        setTransfers((prev) => {
+            const next = new Map(prev);
+            for (const [id, t] of next) {
+                if (t.status === 'complete' || t.status === 'cancelled' || t.status === 'error') {
+                    next.delete(id);
+                }
+            }
+            return next;
+        });
+    }, []);
+    return { transfers, send, accept, reject, cancel, listenToPeer, clearCompleted };
+}

package/dist/react/useIdentity.d.ts

@@ -0,0 +1,9 @@
+import type { IdentityKeys } from '../core/types';
+export declare function useIdentity(persistKey?: string): {
+    ready: boolean;
+    fingerprint: string;
+    exportKeys: () => Promise<IdentityKeys | null>;
+    regenerate: () => Promise<void>;
+    clear: () => void;
+    error: Error | null;
+};

package/dist/react/useIdentity.js

@@ -0,0 +1,63 @@
+import { useEffect, useState, useCallback, useRef } from 'react';
+import { Identity } from '../core/identity';
+const STORAGE_KEY = 'peerlib_identity';
+export function useIdentity(persistKey = STORAGE_KEY) {
+    const [ready, setReady] = useState(false);
+    const [fingerprint, setFingerprint] = useState('');
+    const [error, setError] = useState(null);
+    const idRef = useRef(null);
+    useEffect(() => {
+        const id = new Identity();
+        idRef.current = id;
+        const init = async () => {
+            try {
+                const stored = typeof localStorage !== 'undefined' ? localStorage.getItem(persistKey) : null;
+                if (stored) {
+                    await id.restore(JSON.parse(stored));
+                }
+                else {
+                    await id.generate();
+                    const exported = await id.export();
+                    if (typeof localStorage !== 'undefined') {
+                        localStorage.setItem(persistKey, JSON.stringify(exported));
+                    }
+                }
+                setFingerprint(id.fingerprint);
+                setReady(true);
+            }
+            catch (e) {
+                setError(e instanceof Error ? e : new Error(String(e)));
+            }
+        };
+        init();
+        return () => { idRef.current = null; };
+    }, [persistKey]);
+    const exportKeys = useCallback(async () => {
+        if (!idRef.current)
+            return null;
+        return idRef.current.export();
+    }, []);
+    const regenerate = useCallback(async () => {
+        if (!idRef.current)
+            return;
+        try {
+            await idRef.current.generate();
+            const exported = await idRef.current.export();
+            if (typeof localStorage !== 'undefined') {
+                localStorage.setItem(persistKey, JSON.stringify(exported));
+            }
+            setFingerprint(idRef.current.fingerprint);
+        }
+        catch (e) {
+            setError(e instanceof Error ? e : new Error(String(e)));
+        }
+    }, [persistKey]);
+    const clear = useCallback(() => {
+        if (typeof localStorage !== 'undefined') {
+            localStorage.removeItem(persistKey);
+        }
+        setFingerprint('');
+        setReady(false);
+    }, [persistKey]);
+    return { ready, fingerprint, exportKeys, regenerate, clear, error };
+}

package/dist/react/useMatch.d.ts

@@ -0,0 +1,11 @@
+import type { PeerInfo, MatchResult } from '../core/types';
+type MatchStatus = 'idle' | 'matching' | 'matched' | 'error';
+export declare function useMatch(): {
+    match: (namespace: string, meta?: Record<string, any>, count?: number) => Promise<MatchResult | undefined>;
+    status: MatchStatus;
+    peers: PeerInfo[];
+    sessionId: string;
+    reset: () => void;
+    error: Error | null;
+};
+export {};

package/dist/react/useMatch.js

@@ -0,0 +1,33 @@
+import { useState, useCallback } from 'react';
+import { usePeerContext } from './PeerProvider';
+export function useMatch() {
+    const { client } = usePeerContext();
+    const [status, setStatus] = useState('idle');
+    const [peers, setPeers] = useState([]);
+    const [sessionId, setSessionId] = useState('');
+    const [error, setError] = useState(null);
+    const match = useCallback(async (namespace, meta, count) => {
+        if (!client)
+            return;
+        setStatus('matching');
+        setError(null);
+        try {
+            const result = await client.match(namespace, meta, count);
+            setPeers(result.peers);
+            setSessionId(result.session_id);
+            setStatus('matched');
+            return result;
+        }
+        catch (e) {
+            setError(e instanceof Error ? e : new Error(String(e)));
+            setStatus('error');
+        }
+    }, [client]);
+    const reset = useCallback(() => {
+        setStatus('idle');
+        setPeers([]);
+        setSessionId('');
+        setError(null);
+    }, []);
+    return { match, status, peers, sessionId, reset, error };
+}

package/dist/react/useMedia.d.ts

@@ -0,0 +1,13 @@
+export declare function useMedia(roomId: string, type?: 'direct' | 'group', create?: boolean, audio?: boolean, video?: boolean): {
+    localStream: MediaStream | null;
+    remoteStreams: Map<string, MediaStream>;
+    audioMuted: boolean;
+    videoMuted: boolean;
+    muteAudio: () => void;
+    unmuteAudio: () => void;
+    muteVideo: () => void;
+    unmuteVideo: () => void;
+    toggleAudio: () => void;
+    toggleVideo: () => void;
+    error: Error | null;
+};

package/dist/react/useMedia.js

@@ -0,0 +1,89 @@
+import { useEffect, useState, useCallback, useRef } from 'react';
+import { usePeerContext } from './PeerProvider';
+import { DirectMedia, GroupMedia } from '../media';
+export function useMedia(roomId, type = 'direct', create = false, audio = true, video = true) {
+    const { client } = usePeerContext();
+    const [localStream, setLocalStream] = useState(null);
+    const [remoteStreams, setRemoteStreams] = useState(new Map());
+    const [audioMuted, setAudioMuted] = useState(false);
+    const [videoMuted, setVideoMuted] = useState(false);
+    const [error, setError] = useState(null);
+    const mediaRef = useRef(null);
+    useEffect(() => {
+        if (!client || !roomId)
+            return;
+        const media = type === 'group'
+            ? new GroupMedia(client, roomId)
+            : new DirectMedia(client, roomId);
+        mediaRef.current = media;
+        media.on('local_stream', (stream) => setLocalStream(stream));
+        media.on('remote_stream', (stream, fp) => {
+            setRemoteStreams((prev) => new Map(prev).set(fp, stream));
+        });
+        media.on('remote_stream_removed', (fp) => {
+            setRemoteStreams((prev) => {
+                const next = new Map(prev);
+                next.delete(fp);
+                return next;
+            });
+        });
+        media.on('error', (e) => {
+            setError(e instanceof Error ? e : new Error(String(e)));
+        });
+        const init = async () => {
+            try {
+                if (create) {
+                    await media.createAndJoin({ audio, video });
+                }
+                else {
+                    await media.joinAndStart({ audio, video });
+                }
+            }
+            catch (e) {
+                setError(e instanceof Error ? e : new Error(String(e)));
+            }
+        };
+        init();
+        return () => {
+            media.close();
+            mediaRef.current = null;
+            setLocalStream(null);
+            setRemoteStreams(new Map());
+        };
+    }, [client, roomId, type, create, audio, video]);
+    const muteAudio = useCallback(() => {
+        mediaRef.current?.muteAudio();
+        setAudioMuted(true);
+    }, []);
+    const unmuteAudio = useCallback(() => {
+        mediaRef.current?.unmuteAudio();
+        setAudioMuted(false);
+    }, []);
+    const muteVideo = useCallback(() => {
+        mediaRef.current?.muteVideo();
+        setVideoMuted(true);
+    }, []);
+    const unmuteVideo = useCallback(() => {
+        mediaRef.current?.unmuteVideo();
+        setVideoMuted(false);
+    }, []);
+    const toggleAudio = useCallback(() => {
+        audioMuted ? unmuteAudio() : muteAudio();
+    }, [audioMuted, muteAudio, unmuteAudio]);
+    const toggleVideo = useCallback(() => {
+        videoMuted ? unmuteVideo() : muteVideo();
+    }, [videoMuted, muteVideo, unmuteVideo]);
+    return {
+        localStream,
+        remoteStreams,
+        audioMuted,
+        videoMuted,
+        muteAudio,
+        unmuteAudio,
+        muteVideo,
+        unmuteVideo,
+        toggleAudio,
+        toggleVideo,
+        error,
+    };
+}

package/dist/react/useNamespace.d.ts

@@ -0,0 +1,7 @@
+import type { PeerInfo } from '../core/types';
+export declare function useNamespace(namespace: string): {
+    peers: PeerInfo[];
+    joined: boolean;
+    discover: (limit?: number) => Promise<PeerInfo[]>;
+    error: Error | null;
+};

package/dist/react/useNamespace.js

@@ -0,0 +1,38 @@
+import { useEffect, useState, useCallback } from 'react';
+import { usePeerContext } from './PeerProvider';
+export function useNamespace(namespace) {
+    const { client } = usePeerContext();
+    const [peers, setPeers] = useState([]);
+    const [joined, setJoined] = useState(false);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        if (!client || !namespace)
+            return;
+        const offJoined = client.on('peer_joined', (info) => {
+            setPeers((prev) => [...prev.filter((p) => p.fingerprint !== info.fingerprint), info]);
+        });
+        const offLeft = client.on('peer_left', (fp) => {
+            setPeers((prev) => prev.filter((p) => p.fingerprint !== fp));
+        });
+        client.join(namespace)
+            .then((list) => {
+            setPeers(list.filter((p) => p.fingerprint !== client.fingerprint));
+            setJoined(true);
+        })
+            .catch((e) => setError(e instanceof Error ? e : new Error(String(e))));
+        return () => {
+            offJoined();
+            offLeft();
+            client.leave(namespace);
+            setJoined(false);
+            setPeers([]);
+        };
+    }, [client, namespace]);
+    const discover = useCallback(async (limit) => {
+        if (!client)
+            return [];
+        const result = await client.discover(namespace, limit);
+        return result;
+    }, [client, namespace]);
+    return { peers, joined, discover, error };
+}

package/dist/react/usePeer.d.ts

@@ -0,0 +1,6 @@
+import type { Peer } from '../core/peer';
+export declare function usePeer(fingerprint: string): {
+    peer: Peer | null;
+    connectionState: string;
+    send: (data: any, channel?: string) => void;
+};