@poolse/react 2.17.1 → 2.19.0

package/dist/index.d.cts

@@ -682,6 +682,33 @@ interface UseCalls {
     error: Error | null;
     /** Ring every other member of a conversation. */
     call: (conversationId: string, media?: CallMedia) => Promise<void>;
+    /**
+     * Register a ring that arrived by some route other than the socket —
+     * in practice a VoIP push.
+     *
+     * Without this the push path shows a ring the state machine knows
+     * nothing about, and every signal that ends a call is guarded on
+     * state the machine never had: the caller hanging up sent
+     * `call:cancelled`, the guard found no matching `incoming`, and the
+     * callee's phone rang on until its own timeout.
+     *
+     * Idempotent per call id, because the socket almost always delivers
+     * the same call a moment later — that is one ring arriving twice, not
+     * a second caller.
+     */
+    ring: (call: IncomingCall) => void;
+    /**
+     * A call was torn down from outside this state machine.
+     *
+     * The counterpart to {@link ring}: the caller withdrew, or the call
+     * ended, and the news reached this device as a VoIP push rather than
+     * over the socket — which is the normal case for a phone that was
+     * asleep when the ring arrived and whose socket may not be up yet.
+     *
+     * Ignores call ids this client is not in, so a teardown for a
+     * previous call cannot end the current one.
+     */
+    dropped: (callId: string) => void;
     /**
      * Answer the inbound ring.
      *

package/dist/index.d.ts

@@ -682,6 +682,33 @@ interface UseCalls {
     error: Error | null;
     /** Ring every other member of a conversation. */
     call: (conversationId: string, media?: CallMedia) => Promise<void>;
+    /**
+     * Register a ring that arrived by some route other than the socket —
+     * in practice a VoIP push.
+     *
+     * Without this the push path shows a ring the state machine knows
+     * nothing about, and every signal that ends a call is guarded on
+     * state the machine never had: the caller hanging up sent
+     * `call:cancelled`, the guard found no matching `incoming`, and the
+     * callee's phone rang on until its own timeout.
+     *
+     * Idempotent per call id, because the socket almost always delivers
+     * the same call a moment later — that is one ring arriving twice, not
+     * a second caller.
+     */
+    ring: (call: IncomingCall) => void;
+    /**
+     * A call was torn down from outside this state machine.
+     *
+     * The counterpart to {@link ring}: the caller withdrew, or the call
+     * ended, and the news reached this device as a VoIP push rather than
+     * over the socket — which is the normal case for a phone that was
+     * asleep when the ring arrived and whose socket may not be up yet.
+     *
+     * Ignores call ids this client is not in, so a teardown for a
+     * previous call cannot end the current one.
+     */
+    dropped: (callId: string) => void;
     /**
      * Answer the inbound ring.
      *

package/dist/index.js

@@ -1341,6 +1341,8 @@ function useCalls(userId, opts = {}) {
   const isCurrent = useCallback((callId) => {
     return callId === activeCallIdRef.current || callId === incomingRef.current?.callId || callId === outgoingRef.current?.callId;
   }, []);
+  const rejectedRef = useRef(/* @__PURE__ */ new Map());
+  const pendingRef = useRef(null);
   const actionsRef = useRef({
     cancel: async () => {
     },
@@ -1348,9 +1350,24 @@ function useCalls(userId, opts = {}) {
     }
   });
   const calls = useMemo(() => userId ? poolse.realtime.calls(userId) : null, [poolse, userId]);
+  const reject = 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);
+  }, []);
   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(() => {
         });
@@ -1367,17 +1384,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;
@@ -1403,11 +1414,22 @@ function useCalls(userId, opts = {}) {
       offEnded();
       offCancelled();
     };
-  }, [calls, isCurrent]);
+  }, [calls, isCurrent, reject]);
+  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 = 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);
@@ -1421,10 +1443,40 @@ function useCalls(userId, opts = {}) {
     },
     [calls]
   );
+  const ring = 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 = 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 = 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);
@@ -1441,7 +1493,15 @@ function useCalls(userId, opts = {}) {
   const decline = 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) {
@@ -1504,6 +1564,8 @@ function useCalls(userId, opts = {}) {
     }
   }, [calls, phase, incoming, outgoing, activeConversationId, activeCallId]);
   const reset = useCallback(() => {
+    rejectedRef.current = /* @__PURE__ */ new Map();
+    pendingRef.current = null;
     setPhase("idle");
     setIncoming(null);
     setOutgoing(null);
@@ -1521,6 +1583,8 @@ function useCalls(userId, opts = {}) {
     media,
     error,
     call,
+    ring,
+    dropped,
     accept,
     decline,
     cancel,