@poolse/react 2.27.0 → 2.29.0

package/CHANGELOG.md

@@ -4,6 +4,15 @@ All notable changes to `@poolse/react` are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow
 [semver](https://semver.org).
 
+## [2.29.0] — 2026-10-22
+
+### Removed
+
+- **`useCalls` and `useVoiceRoom`** — the legacy socket-ringing calls and
+  the peer-to-peer voice room, both retired on the server. Use `useRoom`
+  (rooms, opt-in ringing) and `useLiveCall` on the web; phones use
+  `@poolse/react-native-calls`.
+
 ## [2.24.0] — 2026-10-14
 
 ### Fixed

package/dist/index.cjs

@@ -1238,384 +1238,6 @@ function useCallRoom(conversationId, opts) {
     toggleMic
   };
 }
-function useAloneWatch({ active, others, graceMs }) {
-  const [alone, setAlone] = react.useState(false);
-  const seenPeer = react.useRef(false);
-  react.useEffect(() => {
-    if (!active) {
-      seenPeer.current = false;
-      setAlone(false);
-      return;
-    }
-    if (others > 0) {
-      seenPeer.current = true;
-      return;
-    }
-    if (graceMs <= 0 || !seenPeer.current) return;
-    const timer = setTimeout(() => setAlone(true), graceMs);
-    return () => clearTimeout(timer);
-  }, [active, others, graceMs]);
-  return alone;
-}
-
-// src/use-voice-room.ts
-function useVoiceRoom(conversationId, opts = {}) {
-  const poolse = usePoolse();
-  const [status, setStatus] = react.useState("idle");
-  const [participants, setParticipants] = react.useState([]);
-  const [muted, setMuted] = react.useState(false);
-  const [error, setError] = react.useState(null);
-  const optsRef = react.useRef(opts);
-  const joined = react.useRef(false);
-  const held = react.useRef(null);
-  const room = react.useMemo(
-    () => conversationId ? poolse.realtime.voice(conversationId, optsRef.current) : null,
-    [poolse, conversationId]
-  );
-  react.useEffect(() => {
-    if (!room) return;
-    held.current = room;
-    setStatus(room.getStatus());
-    setParticipants(room.getParticipants());
-    setMuted(room.isMuted());
-    const offStatus = room.onStatus(setStatus);
-    const offRoster = room.onParticipants(setParticipants);
-    const offError = room.onError(setError);
-    return () => {
-      offStatus();
-      offRoster();
-      offError();
-      held.current = null;
-      if (joined.current) {
-        joined.current = false;
-        room.leave();
-      }
-    };
-  }, [room]);
-  const join = react.useCallback(async () => {
-    const target = room;
-    if (!target) return;
-    setError(null);
-    try {
-      await target.join();
-      if (held.current !== target) {
-        target.leave();
-        return;
-      }
-      joined.current = true;
-    } catch (err) {
-      setError(err instanceof Error ? err : new Error(String(err)));
-    }
-  }, [room]);
-  const leave = react.useCallback(() => {
-    if (!joined.current) return;
-    joined.current = false;
-    room?.leave();
-  }, [room]);
-  const toggleMute = react.useCallback(() => {
-    if (!room) return;
-    setMuted(room.toggleMute());
-  }, [room]);
-  const alone = useAloneWatch({
-    active: status === "connected",
-    others: Math.max(0, participants.length - 1),
-    graceMs: optsRef.current.aloneGraceMs ?? 1500
-  });
-  return { status, participants, muted, alone, error, join, leave, toggleMute };
-}
-function useCalls(userId, opts = {}) {
-  const ringTimeoutMs = opts.ringTimeoutMs ?? 45e3;
-  const poolse = usePoolse();
-  const [phase, setPhase] = react.useState("idle");
-  const phaseRef = react.useRef("idle");
-  phaseRef.current = phase;
-  const [incoming, setIncoming] = react.useState(null);
-  const [outgoing, setOutgoing] = react.useState(null);
-  const [activeConversationId, setActiveConversationId] = react.useState(null);
-  const [activeCallId, setActiveCallId] = react.useState(null);
-  const [activeMedia, setActiveMedia] = react.useState(null);
-  const [error, setError] = react.useState(null);
-  const incomingRef = react.useRef(null);
-  incomingRef.current = incoming;
-  const outgoingRef = react.useRef(null);
-  outgoingRef.current = outgoing;
-  const activeCallIdRef = react.useRef(null);
-  activeCallIdRef.current = activeCallId;
-  const isCurrent = react.useCallback((callId) => {
-    return callId === activeCallIdRef.current || callId === incomingRef.current?.callId || callId === outgoingRef.current?.callId;
-  }, []);
-  const rejectedRef = react.useRef(/* @__PURE__ */ new Map());
-  const pendingRef = react.useRef(null);
-  const actionsRef = react.useRef({
-    cancel: async () => {
-    },
-    decline: async () => {
-    }
-  });
-  const calls = react.useMemo(() => userId ? poolse.realtime.calls(userId) : null, [poolse, userId]);
-  const reject = react.useCallback((callId, userId2, kind) => {
-    if (phaseRef.current !== "ringing-out") return;
-    const out = outgoingRef.current;
-    if (!out || out.callId !== callId) return;
-    rejectedRef.current.set(userId2, kind);
-    const outstanding = out.calleeUserIds.filter((id) => !rejectedRef.current.has(id));
-    if (out.calleeUserIds.length > 0 && outstanding.length > 0) return;
-    const allBusy = [...rejectedRef.current.values()].every((k) => k === "busy");
-    setPhase(allBusy ? "busy" : "declined");
-    setOutgoing(null);
-    setActiveCallId(null);
-    setActiveMedia(null);
-  }, []);
-  react.useEffect(() => {
-    if (!calls) return;
-    const offIncoming = calls.onIncoming((call2) => {
-      if (call2.callId === incomingRef.current?.callId) return;
-      if (call2.callId === activeCallIdRef.current) return;
-      if (phaseRef.current !== "idle") {
-        void calls.markBusy(call2).catch(() => {
-        });
-        return;
-      }
-      setIncoming(call2);
-      setPhase("ringing-in");
-    });
-    const offAccepted = calls.onAccepted((call2) => {
-      if (outgoingRef.current && call2.callId !== outgoingRef.current.callId) return;
-      setPhase("active");
-      setActiveConversationId(call2.conversationId);
-      setActiveCallId(call2.callId);
-    });
-    const offDeclined = calls.onDeclined((call2) => {
-      if (!isCurrent(call2.callId)) return;
-      reject(call2.callId, call2.userId, "declined");
-    });
-    const offBusy = calls.onBusy((call2) => {
-      if (!isCurrent(call2.callId)) return;
-      reject(call2.callId, call2.userId, "busy");
-    });
-    const offEnded = calls.onEnded((call2) => {
-      if (!isCurrent(call2.callId)) return;
-      setPhase("idle");
-      setIncoming(null);
-      setOutgoing(null);
-      setActiveConversationId(null);
-      setActiveCallId(null);
-      setActiveMedia(null);
-    });
-    const offCancelled = calls.onCancelled((call2) => {
-      if (call2.callId !== incomingRef.current?.callId) return;
-      setIncoming(null);
-      setPhase("idle");
-      setActiveCallId(null);
-      setActiveMedia(null);
-    });
-    return () => {
-      offIncoming();
-      offAccepted();
-      offDeclined();
-      offBusy();
-      offEnded();
-      offCancelled();
-    };
-  }, [calls, isCurrent, reject]);
-  react.useEffect(() => {
-    if (!calls) return;
-    const queued = pendingRef.current;
-    if (!queued) return;
-    pendingRef.current = null;
-    const sent = queued.kind === "accept" ? calls.accept(queued.call) : calls.decline(queued.call);
-    void sent.catch((err) => {
-      setError(err instanceof Error ? err : new Error(String(err)));
-    });
-  }, [calls]);
-  const call = react.useCallback(
-    async (conversationId, media2 = "audio") => {
-      if (!calls) return;
-      setError(null);
-      rejectedRef.current = /* @__PURE__ */ new Map();
-      try {
-        const placed = await calls.invite(conversationId, media2);
-        setOutgoing(placed);
-        setActiveCallId(placed.callId);
-        setActiveMedia(placed.media);
-        setPhase("ringing-out");
-      } catch (err) {
-        setError(err instanceof Error ? err : new Error(String(err)));
-        setPhase("idle");
-      }
-    },
-    [calls]
-  );
-  const ring = react.useCallback((call2) => {
-    if (incomingRef.current?.callId === call2.callId) return;
-    if (activeCallIdRef.current === call2.callId) return;
-    if (phaseRef.current !== "idle") return;
-    setIncoming(call2);
-    setPhase("ringing-in");
-  }, []);
-  const dropped = react.useCallback(
-    (callId) => {
-      if (pendingRef.current?.call.callId === callId) pendingRef.current = null;
-      if (!isCurrent(callId)) return;
-      rejectedRef.current = /* @__PURE__ */ new Map();
-      setPhase("idle");
-      setIncoming(null);
-      setOutgoing(null);
-      setActiveConversationId(null);
-      setActiveCallId(null);
-      setActiveMedia(null);
-    },
-    [isCurrent]
-  );
-  const accept = react.useCallback(
-    async (call2) => {
-      const target = call2 ?? incoming;
-      if (!target) return;
-      if (!calls) {
-        pendingRef.current = { kind: "accept", call: target };
-        setActiveConversationId(target.conversationId);
-        setActiveCallId(target.callId);
-        setActiveMedia(target.media);
-        setPhase("active");
-        setIncoming(null);
-        return;
-      }
-      setActiveConversationId(target.conversationId);
-      setActiveCallId(target.callId);
-      setActiveMedia(target.media);
-      setPhase("active");
-      setIncoming(null);
-      try {
-        await calls.accept(target);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        if (message.includes("timed out")) return;
-        setPhase("idle");
-        setActiveConversationId(null);
-        setActiveCallId(null);
-        setActiveMedia(null);
-        setError(err instanceof Error ? err : new Error(String(err)));
-      }
-    },
-    [calls, incoming]
-  );
-  const decline = react.useCallback(
-    async (call2) => {
-      const target = call2 ?? incoming;
-      if (!target) return;
-      if (!calls) {
-        pendingRef.current = { kind: "decline", call: target };
-        setIncoming(null);
-        setActiveCallId(null);
-        setActiveMedia(null);
-        setPhase("idle");
-        return;
-      }
-      try {
-        await calls.decline(target);
-      } catch (err) {
-        setError(err instanceof Error ? err : new Error(String(err)));
-      } finally {
-        setIncoming(null);
-        setActiveCallId(null);
-        setActiveMedia(null);
-        setPhase("idle");
-      }
-    },
-    [calls, incoming]
-  );
-  const cancel = react.useCallback(async () => {
-    if (!calls || !outgoing) return;
-    try {
-      await calls.cancel(outgoing);
-    } catch (err) {
-      setError(err instanceof Error ? err : new Error(String(err)));
-    } finally {
-      setOutgoing(null);
-      setActiveCallId(null);
-      setActiveMedia(null);
-      setPhase("idle");
-    }
-  }, [calls, outgoing]);
-  actionsRef.current = { cancel, decline };
-  react.useEffect(() => {
-    if (ringTimeoutMs <= 0) return;
-    if (phase !== "ringing-out" && phase !== "ringing-in") return;
-    const outbound = phase === "ringing-out";
-    const timer = setTimeout(() => {
-      void (outbound ? actionsRef.current.cancel() : actionsRef.current.decline()).finally(() => {
-        if (outbound) setPhase("timed-out");
-      });
-    }, ringTimeoutMs);
-    return () => clearTimeout(timer);
-  }, [phase, ringTimeoutMs]);
-  const othersOnCallRef = react.useRef(0);
-  const reportOthersOnCall = react.useCallback((count) => {
-    othersOnCallRef.current = count;
-  }, []);
-  const hangUp = react.useCallback(async () => {
-    if (phaseRef.current === "active" && othersOnCallRef.current >= 2) {
-      setPhase("idle");
-      setIncoming(null);
-      setOutgoing(null);
-      setActiveConversationId(null);
-      setActiveCallId(null);
-      setActiveMedia(null);
-      setError(null);
-      return;
-    }
-    const conversationId = activeConversationId ?? incoming?.conversationId ?? outgoing?.conversationId;
-    const callId = activeCallId ?? incoming?.callId ?? outgoing?.callId;
-    try {
-      if (!calls || !callId || !conversationId) return;
-      if (phase === "ringing-out" && outgoing) {
-        await calls.cancel(outgoing);
-      } else if (phase === "ringing-in" && incoming) {
-        await calls.decline(incoming);
-      } else if (phase === "active") {
-        await calls.hangUp({ callId, conversationId });
-      }
-    } catch (err) {
-      setError(err instanceof Error ? err : new Error(String(err)));
-    } finally {
-      setPhase("idle");
-      setIncoming(null);
-      setOutgoing(null);
-      setActiveConversationId(null);
-      setActiveCallId(null);
-      setActiveMedia(null);
-    }
-  }, [calls, phase, incoming, outgoing, activeConversationId, activeCallId]);
-  const reset = react.useCallback(() => {
-    rejectedRef.current = /* @__PURE__ */ new Map();
-    pendingRef.current = null;
-    setPhase("idle");
-    setIncoming(null);
-    setOutgoing(null);
-    setActiveConversationId(null);
-    setActiveCallId(null);
-    setActiveMedia(null);
-    setError(null);
-  }, []);
-  const media = incoming?.media ?? outgoing?.media ?? activeMedia ?? "audio";
-  return {
-    phase,
-    incoming,
-    outgoing,
-    activeConversationId,
-    media,
-    error,
-    call,
-    ring,
-    dropped,
-    accept,
-    decline,
-    cancel,
-    hangUp,
-    reportOthersOnCall,
-    reset
-  };
-}
 function useLiveCall(conversationId) {
   const chat = usePoolse();
   const [call, setCall] = react.useState(null);
@@ -1667,6 +1289,55 @@ function useLiveCall(conversationId) {
   }, [chat, conversationId, apply, refresh]);
   return { call, participantIds, refresh };
 }
+function useRoom(conversationId, opts) {
+  const poolse = usePoolse();
+  const { call: live, participantIds } = useLiveCall(conversationId);
+  const media = useCallRoom(conversationId, { livekit: opts.livekit, aloneGraceMs: 0 });
+  const session = react.useRef(null);
+  const [joining, setJoining] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  react.useEffect(() => {
+    session.current = null;
+    setError(null);
+  }, [conversationId]);
+  const join = react.useCallback(
+    async (kind = "audio", joinOpts = {}) => {
+      if (!conversationId) return;
+      setJoining(true);
+      setError(null);
+      try {
+        session.current = joinOpts.ring ? await poolse.rooms.ring(conversationId, kind) : await poolse.rooms.start(conversationId, kind);
+        const connected = await media.join();
+        if (!connected) throw new Error("Rooms need the SFU, which this deployment does not have.");
+        if (kind === "video") await media.setCameraEnabled(true);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        media.leave();
+      } finally {
+        setJoining(false);
+      }
+    },
+    [poolse, conversationId, media]
+  );
+  const leave = react.useCallback(() => {
+    media.leave();
+    const s = session.current;
+    session.current = null;
+    if (s) void poolse.rooms.leave(s).catch(() => {
+    });
+  }, [poolse, media]);
+  const joined = media.status === "connected" || media.status === "connecting" || joining;
+  return {
+    live,
+    presentIds: participantIds,
+    joined,
+    joining,
+    join,
+    leave,
+    media,
+    error: error ?? media.error
+  };
+}
 function useReadReceipts() {
   const chat = usePoolse();
   const { me } = useMe();
@@ -1759,7 +1430,6 @@ exports.sameGroup = sameGroup;
 exports.useAttachmentUpload = useAttachmentUpload;
 exports.useAttachmentUrl = useAttachmentUrl;
 exports.useCallRoom = useCallRoom;
-exports.useCalls = useCalls;
 exports.useConversation = useConversation;
 exports.useConversations = useConversations;
 exports.useLiveCall = useLiveCall;
@@ -1771,9 +1441,9 @@ exports.usePresence = usePresence;
 exports.useReactions = useReactions;
 exports.useReadReceipts = useReadReceipts;
 exports.useRealtimeStatus = useRealtimeStatus;
+exports.useRoom = useRoom;
 exports.useThread = useThread;
 exports.useTyping = useTyping;
 exports.useUser = useUser;
-exports.useVoiceRoom = useVoiceRoom;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map