@poolse/react 2.18.0 → 2.19.0

package/CHANGELOG.md

@@ -4,6 +4,40 @@ 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.19.0] — 2026-08-25
+
+### Fixed
+
+- **A call cancelled by the caller left the callee's phone ringing.**
+  A ring delivered by VoIP push was shown by CallKit without the state
+  machine ever hearing about it, so `call:cancelled` was matched against
+  an `incoming` that had never been set, failed the guard, and did
+  nothing. The phone rang on until its own 45-second timeout. New
+  `ring()` registers a ring that arrived off-socket; `onIncoming` now
+  recognises the same call arriving by both routes instead of answering
+  your own ring with `call:busy`.
+
+- **Declining a call before the socket was ready told nobody.** The
+  hook builds nothing until it has a user id, and host apps get that
+  from `useMe()` — a network round trip. A VoIP push launches the app
+  cold and CallKit lets you answer or refuse from the lock screen well
+  before that returns, so both actions hit `if (!calls) return` and were
+  dropped. They are now queued and sent the moment the resource exists.
+  `accept()` had the identical hole.
+
+### Changed
+
+- **A group ring no longer ends on the first refusal.** Declines and
+  busies accumulate per callee, and the call ends only once nobody is
+  left who might still pick up. All busy reports busy; any outright
+  refusal reports declined. A decline arriving after somebody answered
+  no longer ends the active call.
+
+### Added
+
+- `dropped(callId)` — a call torn down from outside the state machine,
+  which is how the end of a call reaches a device whose socket isn't up.
+
 ## [2.18.0] — 2026-08-24
 
 Republished in lockstep.

package/dist/index.cjs

@@ -1342,6 +1342,8 @@ function useCalls(userId, opts = {}) {
   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 () => {
     },
@@ -1349,9 +1351,24 @@ function useCalls(userId, opts = {}) {
     }
   });
   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(() => {
         });
@@ -1368,17 +1385,11 @@ function useCalls(userId, opts = {}) {
     });
     const offDeclined = calls.onDeclined((call2) => {
       if (!isCurrent(call2.callId)) return;
-      setPhase("declined");
-      setOutgoing(null);
-      setActiveCallId(null);
-      setActiveMedia(null);
+      reject(call2.callId, call2.userId, "declined");
     });
     const offBusy = calls.onBusy((call2) => {
       if (!isCurrent(call2.callId)) return;
-      setPhase("busy");
-      setOutgoing(null);
-      setActiveCallId(null);
-      setActiveMedia(null);
+      reject(call2.callId, call2.userId, "busy");
     });
     const offEnded = calls.onEnded((call2) => {
       if (!isCurrent(call2.callId)) return;
@@ -1404,11 +1415,22 @@ function useCalls(userId, opts = {}) {
       offEnded();
       offCancelled();
     };
-  }, [calls, isCurrent]);
+  }, [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);
@@ -1422,10 +1444,40 @@ function useCalls(userId, opts = {}) {
     },
     [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 (!calls || !target) return;
+      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;
+      }
       try {
         await calls.accept(target);
         setActiveConversationId(target.conversationId);
@@ -1442,7 +1494,15 @@ function useCalls(userId, opts = {}) {
   const decline = react.useCallback(
     async (call2) => {
       const target = call2 ?? incoming;
-      if (!calls || !target) return;
+      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) {
@@ -1505,6 +1565,8 @@ function useCalls(userId, opts = {}) {
     }
   }, [calls, phase, incoming, outgoing, activeConversationId, activeCallId]);
   const reset = react.useCallback(() => {
+    rejectedRef.current = /* @__PURE__ */ new Map();
+    pendingRef.current = null;
     setPhase("idle");
     setIncoming(null);
     setOutgoing(null);
@@ -1522,6 +1584,8 @@ function useCalls(userId, opts = {}) {
     media,
     error,
     call,
+    ring,
+    dropped,
     accept,
     decline,
     cancel,