vg-x07df 1.9.5 → 1.10.5

package/dist/index.cjs

@@ -1913,6 +1913,14 @@ var callParticipantAddedSchema = zod.z.object({
 var callParticipantKickedSchema = zod.z.object({
   callId: zod.z.string(),
   participantId: zod.z.string(),
+  userId: zod.z.string(),
+  reason: zod.z.string().optional()
+}).strict();
+var callParticipantLeftSchema = zod.z.object({
+  callId: zod.z.string(),
+  userId: zod.z.string(),
+  participantId: zod.z.string(),
+  leftAt: zod.z.string(),
   reason: zod.z.string().optional()
 }).strict();
 var callReadySchema = zod.z.object({
@@ -2272,8 +2280,14 @@ var CallParticipantKickedHandler = class extends BaseSocketHandler {
       participantId: data.participantId,
       reason: data.reason
     });
+    this.updateStore((state) => {
+      if (data.userId && state.outgoingInvites[data.userId]) {
+        delete state.outgoingInvites[data.userId];
+      }
+    });
     this.logger.debug("Participant kicked from call", {
-      participantId: data.participantId
+      participantId: data.participantId,
+      userId: data.userId
     });
   }
 };
@@ -2480,6 +2494,12 @@ var InviteMissedHandler = class extends BaseSocketHandler {
       userId: data.userId
     });
     if (currentState.session?.id !== data.callId) {
+      this.logger.warn("Invite missed ignored due to session mismatch", {
+        eventCallId: data.callId,
+        sessionCallId: currentState.session?.id,
+        hasSession: !!currentState.session,
+        outgoingInviteKeys: Object.keys(currentState.outgoingInvites || {})
+      });
       pushStaleEventError("call:inviteMissed", "callId mismatch", {
         eventCallId: data.callId,
         sessionCallId: currentState.session?.id
@@ -2615,6 +2635,42 @@ var ParticipantAddedHandler = class extends BaseSocketHandler {
   }
 };
 
+// src/core/socketio/handlers/participant-left.handler.ts
+var ParticipantLeftHandler = class extends BaseSocketHandler {
+  constructor() {
+    super(...arguments);
+    this.eventName = "call:participantLeft";
+    this.schema = callParticipantLeftSchema;
+  }
+  handle(data) {
+    const currentState = rtcStore.getState();
+    this.logger.info("Participant left call", {
+      callId: data.callId,
+      userId: data.userId,
+      participantId: data.participantId
+    });
+    if (currentState.session?.id !== data.callId) {
+      pushStaleEventError("call:participantLeft", "callId mismatch", {
+        eventCallId: data.callId,
+        sessionCallId: currentState.session?.id
+      });
+      this.logger.warn("Ignoring participant left for different call", {
+        callId: data.callId
+      });
+      return;
+    }
+    this.updateStore((state) => {
+      if (state.outgoingInvites[data.userId]) {
+        state.outgoingInvites[data.userId].status = "left";
+        this.logger.info("Outgoing invite marked as left", {
+          userId: data.userId,
+          callId: data.callId
+        });
+      }
+    });
+  }
+};
+
 // src/core/socketio/handlers/participant-profiles.handler.ts
 var ParticipantProfilesHandler = class extends BaseSocketHandler {
   constructor() {
@@ -2792,6 +2848,7 @@ var SocketHandlerRegistry = class {
       new InviteCancelledHandler(this.options),
       // Participant management
       new ParticipantAddedHandler(this.options),
+      new ParticipantLeftHandler(this.options),
       new CallParticipantKickedHandler(this.options),
       // Profile hydration
       new ParticipantProfilesHandler(this.options),
@@ -3976,7 +4033,8 @@ function createPresenceService(config, deps) {
     if (userIds.length === 0) {
       return [];
     }
-    const cacheKey = [...userIds].sort().join(",");
+    const uniqueUserIds = Array.from(new Set(userIds));
+    const cacheKey = [...uniqueUserIds].sort().join(",");
     const existing = inFlight.get(cacheKey);
     if (existing) {
       logger7.debug("Reusing in-flight request", { cacheKey });
@@ -3984,7 +4042,7 @@ function createPresenceService(config, deps) {
     }
     const fetchPromise = (async () => {
       try {
-        const response = await signalPresence.queryPresence(userIds);
+        const response = await signalPresence.queryPresence(uniqueUserIds);
         return response.presence.map((p) => ({
           userId: p.userId,
           status: p.status,
@@ -5011,56 +5069,105 @@ var useScreenShare = () => {
     handleStopScreenShare
   };
 };
-function usePresence(userId) {
+function usePresence(userId, options) {
   const sdk = useSdk();
   const [presence, setPresence] = React.useState();
   const [isLoading, setIsLoading] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const isMountedRef = React.useRef(true);
   const refetch = React.useCallback(async () => {
     if (!userId) return;
     setIsLoading(true);
+    setError(null);
     try {
       const result = await sdk.presence.getPresence(userId);
-      setPresence(result);
+      if (isMountedRef.current) {
+        setPresence(result);
+      }
+    } catch (err) {
+      if (isMountedRef.current) {
+        setError(err);
+      }
     } finally {
-      setIsLoading(false);
+      if (isMountedRef.current) {
+        setIsLoading(false);
+      }
     }
   }, [sdk, userId]);
   React.useEffect(() => {
     refetch();
   }, [refetch]);
+  React.useEffect(() => {
+    if (!options?.pollIntervalMs) return;
+    const id = setInterval(refetch, options.pollIntervalMs);
+    return () => clearInterval(id);
+  }, [options?.pollIntervalMs, refetch]);
+  React.useEffect(() => {
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
   return {
     presence,
     status: presence?.status,
+    resolvedStatus: error ? "unknown" : presence?.status,
     isLoading,
+    error,
     refetch
   };
 }
-function usePresenceMany(userIds) {
+function usePresenceMany(userIds, options) {
   const sdk = useSdk();
   const [presences, setPresences] = React.useState(
     /* @__PURE__ */ new Map()
   );
   const [isLoading, setIsLoading] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const isMountedRef = React.useRef(true);
   const refetch = React.useCallback(async () => {
     if (userIds.length === 0) return;
     setIsLoading(true);
+    setError(null);
     try {
       const results = await sdk.presence.queryPresence(userIds);
       const map = /* @__PURE__ */ new Map();
       for (const p of results) {
         map.set(p.userId, p);
       }
-      setPresences(map);
+      if (isMountedRef.current) {
+        setPresences(map);
+      }
+    } catch (err) {
+      if (isMountedRef.current) {
+        setError(err);
+      }
     } finally {
-      setIsLoading(false);
+      if (isMountedRef.current) {
+        setIsLoading(false);
+      }
     }
   }, [sdk, userIds]);
   React.useEffect(() => {
     refetch();
   }, [refetch]);
+  React.useEffect(() => {
+    if (!options?.pollIntervalMs) return;
+    const id = setInterval(refetch, options.pollIntervalMs);
+    return () => clearInterval(id);
+  }, [options?.pollIntervalMs, refetch]);
+  React.useEffect(() => {
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
   return {
     presences,
     isLoading,
+    error,
+    getStatus: (userId) => {
+      if (error) return "unknown";
+      return presences.get(userId)?.status;
+    },
     refetch
   };
 }
@@ -5172,6 +5279,7 @@ exports.callInviteMissedSchema = callInviteMissedSchema;
 exports.callInviteSchema = callInviteSchema;
 exports.callParticipantAddedSchema = callParticipantAddedSchema;
 exports.callParticipantKickedSchema = callParticipantKickedSchema;
+exports.callParticipantLeftSchema = callParticipantLeftSchema;
 exports.callReadySchema = callReadySchema;
 exports.callRecordingStartedSchema = callRecordingStartedSchema;
 exports.callRecordingStoppedSchema = callRecordingStoppedSchema;